neulab/tldr huggingface dataset:
# convert an stl file to a gts file and revert face normals
stl2gts --revert < {{path/to/file.stl}} > {{path/to/file.gts}}
# convert an stl file to a gts file and do not merge vertices
stl2gts --nomerge < {{path/to/file.stl}} > {{path/to/file.gts}}
# convert an stl file to a gts file and display surface statistics
stl2gts --verbose < {{path/to/file.stl}} > {{path/to/file.gts}}
# print help for `stl2gts`
stl2gts --help
# run tests with default configuration or as configured in `mocha.opts`
mocha
# run tests contained at a specific location
mocha {{directory/with/tests}}
# run tests that match a specific grep pattern
mocha --grep {{regular_expression}}
# run tests on changes to javascript files in the current directory and once initially
mocha --watch
# run tests with a specific reporter
mocha --reporter {{reporter}}
# show the default paper size used by all tex live programs
tlmgr paper
# set the default paper size for all tex live programs to a4
sudo tlmgr paper {{a4}}
# show the default paper size used by a specific tex live program
tlmgr {{pdftex}} paper
# set the default paper size for a specific tex live program to a4
sudo tlmgr {{pdftex}} paper {{a4}}
# list all available paper sizes for a specific tex live program
tlmgr {{pdftex}} paper --list
# dump the default paper size used by all tex live programs in json format
tlmgr paper --json
# create a project
scrapy startproject {{project_name}}
# create a spider (in project directory)
scrapy genspider {{spider_name}} {{website_domain}}
# edit spider (in project directory)
scrapy edit {{spider_name}}
# run spider (in project directory)
scrapy crawl {{spider_name}}
# fetch a webpage as scrapy sees it and print the source to stdout
scrapy fetch {{url}}
# open a webpage in the default browser as scrapy sees it (disable javascript for extra fidelity)
scrapy view {{url}}
# open scrapy shell for url, which allows interaction with the page source in a python shell (or ipython if available)
scrapy shell {{url}}
# report what would be removed by git prune without removing it
git prune --dry-run
# prune unreachable objects and display what has been pruned to stdout
git prune --verbose
# prune unreachable objects while showing progress
git prune --progress
# 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}}
# connect to a local database on port 3306, using the current user's username
mycli {{database_name}}
# connect to a database (user will be prompted for a password)
mycli -u {{username}} {{database_name}}
# connect to a database on another host
mycli -h {{database_host}} -P {{port}} -u {{username}} {{database_name}}
# copy your keys to the remote machine
ssh-copy-id {{username@remote_host}}
# copy the given public key to the remote
ssh-copy-id -i {{path/to/certificate}} {{username}}@{{remote_host}}
# copy the given public key to the remote with specific port
ssh-copy-id -i {{path/to/certificate}} -p {{port}} {{username}}@{{remote_host}}
# run a vala file, with gtk+
vala {{path/to/file.vala}} --pkg {{gtk+-3.0}}
# display version info
vala --version
# display helper message
vala --help
# install a package and its dependencies
sudo tlmgr install {{package}}
# reinstall a package
sudo tlmgr install --reinstall {{package}}
# simulate installing a package without making any changes
tlmgr install --dry-run {{package}}
# install a package without its dependencies
sudo tlmgr install --no-depends {{package}}
# install a package from a specific file
sudo tlmgr install --file {{path/to/package}}
# apply the default style of 4 spaces per indent and no formatting changes
astyle {{source_file}}
# apply the java style with attached braces
astyle --style=java {{path/to/file}}
# apply the allman style with broken braces
astyle --style=allman {{path/to/file}}
# apply a custom indent using spaces. choose between 2 and 20 spaces
astyle --indent=spaces={{number_of_spaces}} {{path/to/file}}
# apply a custom indent using tabs. choose between 2 and 20 tabs
astyle --indent=tab={{number_of_tabs}} {{path/to/file}}
# change the password of the current user interactively
passwd
# change the password of a specific user
passwd {{username}}
# get the current status of the user
passwd -S
# make the password of the account blank (it will set the named account passwordless)
passwd -d
# lookup the ip(s) associated with a hostname (a records)
dig +short {{example.com}}
# get a detailed answer for a given domain (a records)
dig +noall +answer {{example.com}}
# query a specific dns record type associated with a given domain name
dig +short {{example.com}} {{A|MX|TXT|CNAME|NS}}
# get all types of records for a given domain name
dig {{example.com}} ANY
# specify an alternate dns server to query
dig @{{8.8.8.8}} {{example.com}}
# perform a reverse dns lookup on an ip address (ptr record)
dig -x {{8.8.8.8}}
# find authoritative name servers for the zone and display soa records
dig +nssearch {{example.com}}
# perform iterative queries and display the entire trace path to resolve a domain name
dig +trace {{example.com}}
# open clementine
clementine
# start playing a music file
clementine {{url/or/path/to/file.ext}}
# toggle between pausing and playing
clementine --play-pause
# stop playback
clementine --stop
# skip to the next track
clementine --next
# skip to the previous track
clementine --previous
# load a playlist file
clementine --load {{path/to/playlist.ext}}
# play the 5th track in the currently loaded playlist
clementine --play-track {{5}}
# start peco on all files in the specified directory
find {{path/to/directory}} -type f | peco
# start peco for running processes
ps aux | peco
# start peco with a specified query
peco --query "{{query}}"
# launch okular
okular
# open specific documents in okular
okular {{path/to/file1 path/to/file2 ...}}
# open a document at a specific page
okular --page {{page_number}} {{path/to/file}}
# open a document in presentation mode
okular --presentation {{path/to/file}}
# open a document and start the print dialog
okular --print {{path/to/file}}
# open a document and search for a specific string
okular --find {{search_string}} {{path/to/file}}
# start an interactive shell session
dash
# execute a command and then exit
dash -c "{{command}}"
# execute a script
dash {{path/to/script.sh}}
# run commands from a script, printing each command before executing it
dash -x {{path/to/script.sh}}
# execute commands from a script, stopping at the first error
dash -e {{path/to/script.sh}}
# read and execute commands from stdin
dash -s
# launch gnucash and load the previously opened file
gnucash
# launch gnucash and load the specified file
gnucash {{path/to/file.gnucash}}
# launch gnucash and load an empty file
gnucash --nofile
# ping a host
ping6 {{host}}
# ping a host only a specific number of times
ping6 -c {{count}} {{host}}
# ping a host, specifying the interval in seconds between requests (default is 1 second)
ping6 -i {{seconds}} {{host}}
# ping a host without trying to lookup symbolic names for addresses
ping6 -n {{host}}
# ping a host and ring the bell when a packet is received (if your terminal supports it)
ping6 -a {{host}}
# run a basic benchmark, performing at least 10 runs
hyperfine '{{make}}'
# run a comparative benchmark
hyperfine '{{make target1}}' '{{make target2}}'
# change minimum number of benchmarking runs
hyperfine --min-runs {{7}} '{{make}}'
# perform benchmark with warmup
hyperfine --warmup {{5}} '{{make}}'
# run a command before each benchmark run (to clear caches, etc.)
hyperfine --prepare '{{make clean}}' '{{make}}'
# run a benchmark where a single parameter changes for each run
hyperfine --prepare '{{make clean}}' --parameter-scan {{num_threads}} {{1}} {{10}} '{{make -j {num_threads}}}'
# boot from image emulating i386 architecture
qemu-system-i386 -hda {{image_name.img}}
# boot from image emulating x64 architecture
qemu-system-x86_64 -hda {{image_name.img}}
# boot qemu instance with a live iso image
qemu-system-i386 -hda {{image_name.img}} -cdrom {{os_image.iso}} -boot d
# specify amount of ram for instance
qemu-system-i386 -m 256 -hda image_name.img -cdrom os-image.iso -boot d
# boot from physical device (e.g. from usb to test bootable medium)
qemu-system-i386 -hda /dev/{{storage_device}}
# display basic information about the current app and available commands
cake
# display a list of available routes
cake routes
# clear configuration caches
cake cache clear_all
# build the metadata cache
cake schema_cache build --connection {{connection}}
# clear the metadata cache
cake schema_cache clear
# clear a single cache table
cake schema_cache clear {{table_name}}
# start a development web server (defaults to port 8765)
cake server
# start a repl (interactive shell)
cake console
# generate a hexdump from a binary file and display the output
xxd {{input_file}}
# generate a hexdump from a binary file and save it as a text file
xxd {{input_file}} {{output_file}}
# display a more compact output, replacing consecutive zeros (if any) with a star
xxd -a {{input_file}}
# display the output with 10 columns of one octet (byte) each
xxd -c {{10}} {{input_file}}
# display output only up to a length of 32 bytes
xxd -l {{32}} {{input_file}}
# display the output in plain mode, without any gaps between the columns
xxd -p {{input_file}}
# revert a plaintext hexdump back into binary, and save it as a binary file
xxd -r -p {{input_file}} {{output_file}}
# detect file(s) encoding according to the system's locale
enca {{file1 file2 ...}}
# detect file(s) encoding specifying a language in the posix/c locale format (e.g. zh_cn, en_us)
enca -L {{language}} {{file1 file2 ...}}
# convert file(s) to a specific encoding
enca -L {{language}} -x {{to_encoding}} {{file1 file2 ...}}
# create a copy of an existing file using a different encoding
enca -L {{language}} -x {{to_encoding}} < {{original_file}} > {{new_file}}
# install a repository's specified submodules
git submodule update --init --recursive
# add a git repository as a submodule
git submodule add {{repository_url}}
# add a git repository as a submodule at the specified directory
git submodule add {{repository_url}} {{path/to/directory}}
# update every submodule to its latest commit
git submodule foreach git pull
# find the processes that have a given file open
lsof {{path/to/file}}
# find the process that opened a local internet port
lsof -i :{{port}}
# only output the process id (pid)
lsof -t {{path/to/file}}
# list files opened by the given user
lsof -u {{username}}
# list files opened by the given command or process
lsof -c {{process_or_command_name}}
# list files opened by a specific process, given its pid
lsof -p {{PID}}
# list open files in a directory
lsof +D {{path/to/directory}}
# find the process that is listening on a local tcp port
lsof -iTCP:{{port}} -sTCP:LISTEN
# display a live stream for the statistics of all running containers
docker stats
# display a live stream of statistics for a spaceseparated list of containers
docker stats {{container_name}}
# change the columns format to display container's cpu usage percentage
docker stats --format "{{.Name}}:\t{{.CPUPerc}}"
# display statistics for all containers (both running and stopped)
docker stats --all
# disable streaming stats and only pull the current stats
docker stats --no-stream
# check the consistency of the whole tex live installation
tlmgr check all
# check the consistency of the whole tex live information in verbose mode
tlmgr check all -v
# check for missing dependencies
tlmgr check depends
# check if all tex live executables are present
tlmgr check executes
# check if all files listed in the local tlpdb are present
tlmgr check files
# check for duplicate filenames in the runfiles sections
tlmgr check runfiles
# start a repl (interactive shell)
scheme
# run a scheme program (with no repl output)
scheme --quiet < {{script.scm}}
# load a scheme program into the repl
scheme --load {{script.scm}}
# load scheme expressions into the repl
scheme --eval "{{(define foo 'x)}}"
# open the repl in quiet mode
scheme --quiet
# print the text message as a large banner (quotes are optional)
banner "{{Hello World}}"
# print the text message as a banner with a width of 50 characters
banner -w {{50}} "{{Hello World}}"
# read text from stdin
banner
# download english subtitles for a video
subliminal download -l {{en}} {{video.ext}}
# print the total number of commits
git count
# print the number of commits per contributor and the total number of commits
git count --all
# process an image file
zbarimg {{image_file}}
# start a repl (interactive shell)
guile
# execute the script in a given scheme file
guile {{script.scm}}
# execute a scheme expression
guile -c "{{expression}}"
# listen on a port or a unix domain socket (the default is port 37146) for remote repl connections
guile --listen={{port_or_socket}}
# read avr microcontroller
avrdude -p {{AVR_device}} -c {{programmer}} -U flash:r:{{file.hex}}:i
# write avr microcontroller
avrdude -p {{AVR_device}} -c {{programmer}} -U flash:w:{{file.hex}}
# list available avr devices
avrdude -p \?
# list available avr programmers
avrdude -c \?
# 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
# start minetest in client mode
minetest
# start minetest in server mode by hosting a specific world
minetest --server --world {{name}}
# write logs to a specific file
minetest --logfile {{path/to/file}}
# only write errors to the console
minetest --quiet
# consume messages starting with the newest offset
kafkacat -C -t {{topic}} -b {{brokers}}
# consume messages starting with the oldest offset and exit after the last message is received
kafkacat -C -t {{topic}} -b {{brokers}} -o beginning -e
# consume messages as a kafka consumer group
kafkacat -G {{group_id}} {{topic}} -b {{brokers}}
# publish message by reading from stdin
echo {{message}} | kafkacat -P -t {{topic}} -b {{brokers}}
# publish messages by reading from a file
kafkacat -P -t {{topic}} -b {{brokers}} {{path/to/file}}
# list metadata for all topics and brokers
kafkacat -L -b {{brokers}}
# list metadata for a specific topic
kafkacat -L -t {{topic}} -b {{brokers}}
# get offset for a topic/partition for a specific point in time
kafkacat -Q -t {{topic}}:{{partition}}:{{unix_timestamp}} -b {{brokers}}
# install or upgrade `gitextras` commands
git extras update
# display help and subcommands
git extras --help
# print the version of installed `gitextras`
git extras --version
# restore an archive into an existing database
pg_restore -d {{db_name}} {{archive_file.dump}}
# same as above, customize username
pg_restore -U {{username}} -d {{db_name}} {{archive_file.dump}}
# same as above, customize host and port
pg_restore -h {{host}} -p {{port}} -d {{db_name}} {{archive_file.dump}}
# list database objects included in the archive
pg_restore --list {{archive_file.dump}}
# clean database objects before creating them
pg_restore --clean -d {{db_name}} {{archive_file.dump}}
# use multiple jobs to do the restoring
pg_restore -j {{2}} -d {{db_name}} {{archive_file.dump}}
# open thunderbird
thunderbird
# use a specific user profile
thunderbird -P {{profile_name}}
# use a specific user profile directory
thunderbird --profile {{path/to/profile/directory}}
# return pids of any running processes with a matching command string
pgrep {{process_name}}
# search for processes including their commandline options
pgrep --full "{{process_name}} {{parameter}}"
# search for processes run by a specific user
pgrep --euid root {{process_name}}
# show the current arp table
arp -a
# clear the entire cache
sudo arp -a -d
# delete a specific entry
arp -d {{address}}
# create an entry in the arp table
arp -s {{address}} {{mac_address}}
# view documentation for the original command
tldr vim
# register a node at a puppet server and apply the received catalog
puppet agent --test --server {{puppetserver_fqdn}} --serverport {{port}} --waitforcert {{poll_time}}
# run the agent in the background (uses settings from `puppet.conf`)
puppet agent
# run the agent once in the foreground, then exit
puppet agent --test
# run the agent in drymode
puppet agent --test --noop
# log every resource being evaluated (even if nothing is being changed)
puppet agent --test --evaltrace
# create a dump of all databases (this will place the files inside a directory called "dump")
mongodump
# specify an output location for the dump
mongodump --out {{path/to/directory}}
# create a dump of a given database
mongodump --db {{database_name}}
# create a dump of a given collection within a given database
mongodump --collection {{collection_name}} --db {{database_name}}
# connect to a given host running on a given port, and create a dump
mongodump --host {{host}} --port {{port}}
# create a dump of a given database with a given username; user will be prompted for password
mongodump --username {{username}} {{database}} --password
# execute a puppet subcommand
puppet {{subcommand}}
# check the puppet version
puppet --version
# display help
puppet --help
# display help for a subcommand
puppet help {{subcommand}}
# validate a device by checking the files in a given directory
f3read {{path/to/mount_point}}
# convert a file to the text format and display it to the console
wasm2wat {{file.wasm}}
# write the output to a given file
wasm2wat {{file.wasm}} -o {{file.wat}}
# open a file and enter normal mode, to execute commands
kak {{path/to/file}}
# enter insert mode from normal mode, to write text into the file
i
# escape insert mode, to go back to normal mode
<Escape>
# replace all instances of "foo" in the current file with "bar"
%s{{foo}}<Enter>c{{bar}}<Escape>
# unselect all secondary selections, and keep only the main one
<Space>
# search for numbers and select the first two
/\d+<Enter>N
# insert the contents of a file
!cat {{path/to/file}}<Enter>
# save the current file
:w<Enter>
# start a repl (interactive shell)
carp
# start a repl with a custom prompt
carp --prompt "{{> }}"
# build a `carp` file
carp -b {{path/to/file.carp}}
# build and run a file
carp -x {{path/to/file.carp}}
# build a file with optimizations enabled
carp -b --optimize {{path/to/file.carp}}
# transpile a file to c code
carp --generate-only {{path/to/file.carp}}
# render an html file to pdf
weasyprint {{path/to/input.html}} {{path/to/output}}.pdf
# render an html file to png, including an additional user stylesheet
weasyprint {{path/to/input.html}} {{path/to/output}}.png --stylesheet {{path/to/stylesheet.css}}
# output additional debugging information when rendering
weasyprint {{path/to/input.html}} {{path/to/output}}.pdf --verbose
# specify a custom resolution when outputting to png
weasyprint {{path/to/input.html}} {{path/to/output}}.png --resolution {{300}}
# specify a base url for relative urls in the input html file
weasyprint {{path/to/input.html}} {{path/to/output}}.png --base-url {{url_or_filename}}
# fork and clone a github repository by its url
git fork {{https://github.com/tldr-pages/tldr}}
# fork and clone a github repository by its slug
git fork {{tldr-pages/tldr}}
# attempt to extract streams from the url specified, and if it's successful, print out a list of available streams to choose from
streamlink {{example.com/stream}}
# open a stream with the specified quality
streamlink {{example.com/stream}} {{720p60}}
# select the highest or lowest available quality
streamlink {{example.com/stream}} {{best|worst}}
# specify which player to use to feed stream data to (vlc is used by default if found)
streamlink --player={{mpv}} {{example.com/stream}} {{best}}
# specify the amount of time to skip from the beginning of the stream. for live streams, this is a negative offset from the end of the stream (rewind)
streamlink --hls-start-offset {{[HH:]MM:SS}} {{example.com/stream}} {{best}}
# skip to the beginning of a live stream, or as far back as possible
streamlink --hls-live-restart {{example.com/stream}} {{best}}
# write stream data to a file instead of playing it
streamlink --output {{path/to/file.ts}} {{example.com/stream}} {{best}}
# open the stream in the player, while at the same time writing it to a file
streamlink --record {{path/to/file.ts}} {{example.com/stream}} {{best}}
# display the default inventory
ansible-inventory --list
# display a custom inventory
ansbile-inventory --list --inventory {{path/to/file_or_script_or_directory}}
# display the default inventory in yaml
ansible-inventory --list --yaml
# dump the default inventory to a file
ansible-inventory --list --output {{path/to/file}}
# output commands to set ls_color using default colors
dircolors
# output commands to set ls_color using colors from a file
dircolors {{file}}
# output commands for bourne shell
dircolors --bourne-shell
# output commands for c shell
dircolors --c-shell
# view the default colors for file types and extensions
dircolors --print-data
# run a process that can live beyond the terminal
nohup {{command}} {{command_options}}
# print a full list of committers to stdout instead of to the `authors` file
git authors --list
# append the list of committers to the `authors` file and open it in the default editor
git authors
# append the list of committers, excluding emails, to the `authors` file and open it in the default editor
git authors --no-email
# show current host name
hostname
# show the network address of the host name
hostname -i
# show all network addresses of the host
hostname -I
# show the fqdn (fully qualified domain name)
hostname --fqdn
# set current host name
hostname {{new_hostname}}
# display the username, line, and time of all currently loggedin sessions
who
# display information only for the current terminal session
who am i
# display all available information
who -a
# display all available information with table headers
who -a -H
# search and list packages from hackage
cabal list {{search_string}}
# show information about a package
cabal info {{package_name}}
# download and install a package
cabal install {{package_name}}
# create a new haskell project in the current directory
cabal init
# build the project in the current directory
cabal build
# run tests of the project in the current directory
cabal test
# list each branch showing date, latest commit hash and message
git brv
# extract the sound from a video and save it as mp3
ffmpeg -i {{video.mp4}} -vn {{sound}}.mp3
# convert frames from a video or gif into individual numbered images
ffmpeg -i {{video.mpg|video.gif}} {{frame_%d.png}}
# combine numbered images (`frame_1.jpg`, `frame_2.jpg`, etc) into a video or gif
ffmpeg -i {{frame_%d.jpg}} -f image2 {{video.mpg|video.gif}}
# quickly extract a single frame from a video at time mmss and save it as a 128x128 resolution image
ffmpeg -ss {{mm:ss}} -i {{video.mp4}} -frames 1 -s {{128x128}} -f image2 {{image.png}}
# trim a video from a given start time mmss to an end time mm2ss2 (omit the to flag to trim till the end)
ffmpeg -ss {{mm:ss}} -to {{mm2:ss2}} -i {{video.mp4}} -codec copy {{output.mp4}}
# convert avi video to mp4. aac audio @ 128kbit, h264 video @ crf 23
ffmpeg -i {{input_video}}.avi -codec:audio aac -b:audio 128k -codec:video libx264 -crf 23 {{output_video}}.mp4
# remux mkv video to mp4 without reencoding audio or video streams
ffmpeg -i {{input_video}}.mkv -codec copy {{output_video}}.mp4
# convert mp4 video to vp9 codec. for the best quality, use a crf value (recommended range 1535) and bvideo must be 0
ffmpeg -i {{input_video}}.mp4 -codec:video libvpx-vp9 -crf {{30}} -b:video 0 -codec:audio libopus -vbr on -threads {{number_of_threads}} {{output_video}}.webm
# publish a temperature value of 32 on the topic `sensors/temperature` to 192.168.1.1 (defaults to `localhost`) with quality of service (`qos`) set to 1
mosquitto_pub -h {{192.168.1.1}} -t {{sensors/temperature}} -m {{32}} -q {{1}}
# publish timestamp and temperature data on the topic `sensors/temperature` to a remote host on a nonstandard port
mosquitto_pub -h {{192.168.1.1}} -p {{1885}} -t {{sensors/temperature}} -m "{{1266193804 32}}"
# publish light switch status and retain the message on the topic `switches/kitchen_lights/status` to a remote host because there may be a long period of time between light switch events
mosquitto_pub -r -h "{{iot.eclipse.org}}" -t {{switches/kitchen_lights/status}} -m "{{on}}"
# send the contents of a file (`data.txt`) as a message and publish it to `sensors/temperature` topic
mosquitto_pub -t {{sensors/temperature}} -f {{data.txt}}
# send the contents of a file (`data.txt`), by reading from stdin and send the entire input as a message and publish it to `sensors/temperature` topic
mosquitto_pub -t {{sensors/temperature}} -s < {{data.txt}}
# read newline delimited data from stdin as a message and publish it to `sensors/temperature` topic
{{echo data.txt}} | mosquitto_pub -t {{sensors/temperature}} -l
# connect to a remote server
ssh {{username}}@{{remote_host}}
# connect to a remote server with a specific identity (private key)
ssh -i {{path/to/key_file}} {{username}}@{{remote_host}}
# connect to a remote server using a specific port
ssh {{username}}@{{remote_host}} -p {{2222}}
# run a command on a remote server with a [t]ty allocation allowing interaction with the remote command
ssh {{username}}@{{remote_host}} -t {{command}} {{command_arguments}}
# ssh tunneling dynamic port forwarding (socks proxy on `localhost1080)
ssh -D {{1080}} {{username}}@{{remote_host}}
# ssh tunneling forward a specific port (`localhost9999` to `example.org80`) along with disabling pseudo[t]ty allocation and executio[n] of remote commands
ssh -L {{9999}}:{{example.org}}:{{80}} -N -T {{username}}@{{remote_host}}
# ssh jumping connect through a jumphost to a remote server (multiple jump hops may be specified separated by comma characters)
ssh -J {{username}}@{{jump_host}} {{username}}@{{remote_host}}
# agent forwarding forward the authentication information to the remote machine (see `man ssh_config` for available options)
ssh -A {{username}}@{{remote_host}}
# list available network interfaces
tcpdump -D
# capture the traffic of a specific interface
tcpdump -i {{eth0}}
# capture all tcp traffic showing contents (ascii) in console
tcpdump -A tcp
# capture the traffic from or to a host
tcpdump host {{www.example.com}}
# capture the traffic from a specific interface, source, destination and destination port
tcpdump -i {{eth0}} src {{192.168.1.1}} and dst {{192.168.1.2}} and dst port {{80}}
# capture the traffic of a network
tcpdump net {{192.168.1.0/24}}
# capture all traffic except traffic over port 22 and save to a dump file
tcpdump -w {{dumpfile.pcap}} port not {{22}}
# read from a given dump file
tcpdump -r {{dumpfile.pcap}}
# format the configuration in the current directory
terraform fmt
# format the configuration in the current directory and subdirectories
terraform fmt -recursive
# display diffs of formatting changes
terraform fmt -diff
# do not list files that were formatted to stdout
terraform fmt -list=false
# initialize a new github cli extension project in a directory of the same name
gh extension create {{extension_name}}
# install an extension from a github repository
gh extension install {{owner}}/{{repository}}
# list installed extensions
gh extension list
# upgrade a specific extension
gh extension upgrade {{extension_name}}
# upgrade all extensions
gh extension upgrade --all
# remove an extension
gh extension remove {{extension_name}}
# display help about a subcommand
gh extension {{subcommand}} --help
# deploy the current directory
now
# display a list of deployments
now list
# display information related to a deployment
now inspect {{deployment_url}}
# remove a deployment
now remove {{deployment_id}}
# log in into an account or create a new one
now login
# initialize an example project (a new directory will be created)
now init
# find files containing "foo", and print the line matches in context
ag {{foo}}
# find files containing "foo" in a specific directory
ag {{foo}} {{path/to/directory}}
# find files containing "foo", but only list the filenames
ag -l {{foo}}
# find files containing "foo" caseinsensitively, and print only the match, rather than the whole line
ag -i -o {{FOO}}
# find "foo" in files with a name matching "bar"
ag {{foo}} -G {{bar}}
# find files whose contents match a regular expression
ag '{{^ba(r|z)$}}'
# find files with a name matching "foo"
ag -g {{foo}}
# 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}}
# overwrite a file
shred {{file}}
# overwrite a file, leaving zeroes instead of random data
shred --zero {{file}}
# overwrite a file 25 times
shred -n25 {{file}}
# overwrite a file and remove it
shred --remove {{file}}
# remove a package and its dependencies
tlmgr remove {{package}}
# display information about a package
tlmgr info {{package}}
# update all packages
tlmgr update --all
# show possible updates without updating anything
tlmgr update --list
# start a gui version of tlmgr
tlmgr gui
# list all tex live configurations
tlmgr conf
# show the remote addresses table only
bandwhich --addresses
# show dns queries
bandwhich --show-dns
# show total (cumulative) usage
bandwhich --total-utilization
# show the network utilization for a specific network interface
bandwhich --interface {{eth0}}
# show dns queries with a given dns server
bandwhich --show-dns --dns-server {{dns_server_ip}}
# render a `png` image with a filename based on the input filename and output format (uppercase o)
circo -T {{png}} -O {{path/to/input.gv}}
# render a `svg` image with the specified output filename (lowercase o)
circo -T {{svg}} -o {{path/to/image.svg}} {{path/to/input.gv}}
# render the output in `ps`, `pdf`, `svg`, `fig`, `png`, `gif`, `jpg`, `json`, or `dot` format
circo -T {{format}} -O {{path/to/input.gv}}
# render a `gif` image using stdin and stdout
echo "{{digraph {this -> that} }}" | circo -T {{gif}} > {{path/to/image.gif}}
# display help
circo -?
# start an interactive shell with a new database
sqlite3
# open an interactive shell against an existing database
sqlite3 {{path/to/database.sqlite3}}
# execute an sql statement against a database and then exit
sqlite3 {{path/to/database.sqlite3}} '{{SELECT * FROM some_table;}}'
# list alive hosts within a subnet generated from a netmask
fping -a -g 192.168.1.0/24
# list alive hosts within a subnet generated from an ip range
fping -a -g 192.168.1.1 192.168.1.254
# list unreachable hosts within a subnet generated from a netmask
fping -u -g 192.168.1.0/24
# generate an encrypted file that can be decrypted with a passphrase
age --passphrase --output {{path/to/encrypted_file}} {{path/to/unencrypted_file}}
# generate a key pair, saving the private key to an unencrypted file and printing the public key to stdout
age-keygen --output {{path/to/file}}
# encrypt a file with one or more public keys that are entered as literals
age --recipient {{public_key_1}} --recipient {{public_key_2}} {{path/to/unencrypted_file}} --output {{path/to/encrypted_file}}
# encrypt a file with one or more public keys that are specified in a recipients file
age --recipients-file {{path/to/recipients_file}} {{path/to/unencrypted_file}} --output {{path/to/encrypted_file}}
# decrypt a file with a passphrase
age --decrypt --output {{path/to/decrypted_file}} {{path/to/encrypted_file}}
# decrypt a file with a private key file
age --decrypt --identity {{path/to/private_key_file}} --output {{path/to/decrypted_file}} {{path/to/encrypted_file}}
# clone a repository using its slug (owners can omit the username)
hub clone {{username}}/{{repo_name}}
# create a fork of the current repository (cloned from another user) under your github profile
hub fork
# push the current local branch to github and create a pr for it in the original repository
hub push {{remote_name}} && hub pull-request
# create a pr of the current (already pushed) branch, reusing the message from the first commit
hub pull-request --no-edit
# create a new branch with the contents of a pull request and switch to it
hub pr checkout {{pr_number}}
# upload the current (localonly) repository to your github account
hub create
# fetch git objects from upstream and update local branches
hub sync
# 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}}
# start wuzz
wuzz
# display help information
F1
# send an http request
Ctrl + R
# switch to the next view
Ctrl + J, Tab
# switch to the previous view
Ctrl + K, Shift + Tab
# update all tex live packages
sudo tlmgr update --all
# update tlmgr itself
sudo tlmgr update --self
# update a specific package
sudo tlmgr update {{package}}
# update all except a specific package
sudo tlmgr update --all --exclude {{package}}
# update all packages, making a backup of the current packages
sudo tlmgr update --all --backup
# update a specific package without updating its dependencies
sudo tlmgr update --no-depends {{package}}
# simulate updating all packages without making any changes
sudo tlmgr update --all --dry-run
# copy a file or directory from the host to a container
docker cp {{path/to/file_or_directory_on_host}} {{container_name}}:{{path/to/file_or_directory_in_container}}
# copy a file or directory from a container to the host
docker cp {{container_name}}:{{path/to/file_or_directory_in_container}} {{path/to/file_or_directory_on_host}}
# copy a file or directory from the host to a container, following symlinks (copies the symlinked files directly, not the symlinks themselves)
docker cp --follow-link {{path/to/symlink_on_host}} {{container_name}}:{{path/to/file_or_directory_in_container}}
# download a url to a file
http --download {{example.org}}
# send formencoded data
http --form {{example.org}} {{name='bob'}} {{profile_picture@'bob.png'}}
# send json object
http {{example.org}} {{name='bob'}}
# specify an http method
http {{HEAD}} {{example.org}}
# include an extra header
http {{example.org}} {{X-MyHeader:123}}
# pass a username and password for server authentication
http --auth {{username:password}} {{example.org}}
# specify raw request body via stdin
cat {{data.txt}} | http PUT {{example.org}}
# display file using default settings octal format, 8 bytes per line, byte offsets in octal, and duplicate lines replaced with `*`
od {{path/to/file}}
# display file in verbose mode, i.e. without replacing duplicate lines with `*`
od -v {{path/to/file}}
# display file in hexadecimal format (2byte units), with byte offsets in decimal format
od --format={{x}} --address-radix={{d}} -v {{path/to/file}}
# display file in hexadecimal format (1byte units), and 4 bytes per line
od --format={{x1}} --width={{4}} -v {{path/to/file}}
# display file in hexadecimal format along with its character representation, and do not print byte offsets
od --format={{xz}} --address-radix={{n}} -v {{path/to/file}}
# read only 100 bytes of a file starting from the 500th byte
od --read-bytes {{100}} --skip-bytes={{500}} -v {{path/to/file}}
# compile source file(s) and create an executable
c99 {{file.c}}
# compile source file(s) and create an executable with a custom name
c99 -o {{executable_name}} {{file.c}}
# compile source file(s) and create object file(s)
c99 -c {{file.c}}
# compile source file(s), link with object file(s), and create an executable
c99 {{file.c}} {{file.o}}
# create a new empty file(s) or change the times for existing file(s) to current time
touch {{filename}}
# set the times on a file to a specific date and time
touch -t {{YYYYMMDDHHMM.SS}} {{filename}}
# use the times from a file to set the times on a second file
touch -r {{filename}} {{filename2}}
# create multiple files
touch {{file{1,2,3}.txt}}
# browse for vnc servers
bvnc
# browse for ssh servers
bvnc --ssh
# browse for both vnc and ssh servers
bvnc --shell
# browse for vnc servers in a specified domain
bvnc --domain={{domain}}
# view documentation for the original command
tldr clang++
# search entries
keepassxc-cli lookup {{path/to/database_file}} {{name}}
# list the contents of a folder
keepassxc-cli ls {{path/to/database_file}} {{/path/to/directory}}
# add an entry with an autogenerated password
keepassxc-cli add --generate {{path/to/database_file}} {{entry_name}}
# delete an entry
keepassxc-cli rm {{path/to/database_file}} {{entry_name}}
# copy an entry's password to the clipboard
keepassxc-cli clip {{path/to/database_file}} {{entry_name}}
# copy a totp code to the clipboard
keepassxc-cli clip --totp {{path/to/database_file}} {{entry_name}}
# generate a passphrase with 7 words
keepassxc-cli diceware --words {{7}}
# generate a password with 16 printable ascii characters
keepassxc-cli generate --lower --upper --numeric --special --length {{16}}
# launch kate and open specific files
kate {{path/to/file1}} {{path/to/file2}}
# open a remote document in kate
kate {{https://example.com/path/to/file}}
# launch kate, creating a new instance even if one is already open
kate --new
# open a file in kate with the cursor at the specific line
kate --line {{line_number}} {{path/to/file}}
# open a file in kate with the cursor at the specific line and column
kate --line {{line_number}} --column {{column_number}} {{path/to/file}}
# launch kate, creating a new temporary file with contents read from stdin
cat {{path/to/file}} | kate --stdin
# display help
kate --help
# display the current date using the default locale's format
date +"%c"
# display the current date in utc and iso 8601 format
date -u +"%Y-%m-%dT%H:%M:%SZ"
# display the current date as a unix timestamp (seconds since the unix epoch)
date +%s
# display a specific date (represented as a unix timestamp) using the default format
date -d @1473305798
# convert a specific date to the unix timestamp format
date -d "{{2018-09-01 00:00}}" +%s --utc
# display the current date using the rfc3339 format (`yyyymmdd hhmmss tz`)
date --rfc-3339=s
# restore an unstaged file to the version of the current commit (head)
git restore {{path/to/file}}
# restore an unstaged file to the version of a specific commit
git restore --source {{commit}} {{path/to/file}}
# discard all unstaged changes to tracked files
git restore :/
# unstage a file
git restore --staged {{path/to/file}}
# unstage all files
git restore --staged :/
# discard all changes to files, both staged and unstaged
git restore --worktree --staged :/
# interactively select sections of files to restore
git restore --patch
# start beanstalkd, listening on port 11300
beanstalkd
# start beanstalkd listening on a custom port and address
beanstalkd -l {{ip_address}} -p {{port_number}}
# persist work queues by saving them to disk
beanstalkd -b {{path/to/persistence_directory}}
# sync to the persistence directory every 500 milliseconds
beanstalkd -b {{path/to/persistence_directory}} -f {{500}}
# display the directory stack with a space between each entry
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
# list files and directories in the current directory, one per line, with details
vdir
# list with sizes displayed in humanreadable units (kb, mb, gb)
vdir -h
# list including hidden files (starting with a dot)
vdir -a
# list files and directories sorting entries by size (largest first)
vdir -S
# list files and directories sorting entries by modification time (newest first)
vdir -t
# list grouping directories first
vdir --group-directories-first
# recursively list all files and directories in a specific directory
vdir --recursive {{path/to/directory}}
# view documentation for the original command
tldr tlmgr platform
# list the contents of the tree on a branch
git ls-tree {{branch_name}}
# list the contents of the tree on a commit, recursing into subtrees
git ls-tree -r {{commit_hash}}
# list only the filenames of the tree on a commit
git ls-tree --name-only {{commit_hash}}
# uninstall a tex live package
sudo tlmgr remove {{package}}
# simulate uninstalling a package without making any changes
tlmgr remove --dry-run {{package}}
# uninstall a package without its dependencies
sudo tlmgr remove --no-depends {{package}}
# uninstall a package and back it up to a specific directory
sudo tlmgr remove --backupdir {{path/to/directory}} {{package}}
# uninstall all of tex live, asking for confirmation
sudo tlmgr remove --all
# change the upstream remote to origin
git rename-remote {{upstream}} {{origin}}
# search for a haxe library
haxelib search {{keyword}}
# install a haxe library
haxelib install {{libname}}
# upgrade all installed haxe libraries
haxelib upgrade
# install the development version of a library from a git repository
haxelib git {{libname}} {{git_url}}
# print the uncompressed contents of a gzipped file to the standard output
zcat {{file.txt.gz}}
# print compression details of a gzipped file to the standard output
zcat -l {{file.txt.gz}}
# start qt creator
qtcreator
# start qt creator and restore the last session
qtcreator -lastsession
# start qt creator but don't load the specified plugin
qtcreator -noload {{plugin}}
# start qt creator but don't load any plugins
qtcreator -noload {{all}}
# start qt creator in presentation mode with popups for keyboard shortcuts
qtcreator -presentationMode
# start qt creator and show the diff from a specific commit
qtcreator -git-show {{commit}}
# parse and check a file for errors
wat2wasm {{file.wat}}
# write the output binary to a given file
wat2wasm {{file.wat}} -o {{file.wasm}}
# display simplified representation of every byte
wat2wasm -v {{file.wat}}
# interactively log into a registry
docker login
# log into a registry with a specific username (user will be prompted for a password)
docker login --username {{username}}
# log into a registry with username and password
docker login --username {{username}} --password {{password}} {{server}}
# log into a registry with password from stdin
echo "{{password}}" | docker login --username {{username}} --password-stdin
# cut out the first sixteen characters of each line of stdin
cut -c {{1-16}}
# cut out the first sixteen characters of each line of the given files
cut -c {{1-16}} {{file}}
# cut out everything from the 3rd character to the end of each line
cut -c {{3-}}
# cut out the fifth field of each line, using a colon as a field delimiter (default delimiter is tab)
cut -d'{{:}}' -f{{5}}
# cut out the 2nd and 10th fields of each line, using a semicolon as a delimiter
cut -d'{{;}}' -f{{2,10}}
# cut out the fields 3 through to the end of each line, using a space as a delimiter
cut -d'{{ }}' -f{{3-}}
# make a new draft
lb new
# edit a draft
lb edit
# delete a draft
lb trash
# publish a draft
lb publish
# delete a published post
lb delete
# unpublish a published post to edit it as a draft again
lb revise
# resize all jpeg images in the directory to 50% of their initial size
mogrify -resize {{50%}} {{*.jpg}}
# resize all images starting with "dsc" to 800x600
mogrify -resize {{800x600}} {{DSC*}}
# convert all pngs in the directory to jpeg
mogrify -format {{jpg}} {{*.png}}
# halve the saturation of all image files in the current directory
mogrify -modulate {{100,50}} {{*}}
# double the brightness of all image files in the current directory
mogrify -modulate {{200}} {{*}}
# scan a file for vulnerabilities
clamscan {{path/to/file}}
# scan all files recursively in a specific directory
clamscan -r {{path/to/directory}}
# scan data from stdin
{{command}} | clamscan -
# specify a virus database file or directory of files
clamscan --database {{path/to/database_file_or_directory}}
# scan the current directory and output only infected files
clamscan --infected
# output the scan report to a log file
clamscan --log {{path/to/log_file}}
# move infected files to a specific directory
clamscan --move {{path/to/quarantine_directory}}
# remove infected files
clamscan --remove yes
# start an interactive shell of `tlmgr`
tlmgr shell
# run any `tlmgr` subcommand in the interactive shell
{{sub_command}} {{arguments}}
# quit the interactive shell
quit
# list all tex live variables
get
# get the value of a tex live variable
get {{variable}}
# set the value of a tex live variable
set {{variable}} {{value}}
# restart the interactive shell
restart
# print the version of the current protocoll
protocol
# convert 1.5k (si units) to 1500
numfmt --from={{si}} {{1.5K}}
# convert 5th field (1indexed) to iec units without converting header
ls -l | numfmt --header={{1}} --field={{5}} --to={{iec}}
# convert to iec units, pad with 5 characters, left aligned
du -s * | numfmt --to={{iec}} --format="{{%-5f}}"
# scan a network for netbios names
nbtscan {{192.168.0.1/24}}
# scan a single ip address
nbtscan {{192.168.0.1}}
# display verbose output
nbtscan -v {{192.168.0.1/24}}
# display output in `/etc/hosts` format
nbtscan -e {{192.168.0.1/24}}
# read ip addresses / networks to scan from a file
nbtscan -f {{path/to/file.txt}}
# create a kubernetes master node
kubeadm init
# bootstrap a kubernetes worker node and join it to a cluster
kubeadm join --token {{token}}
# create a new bootstrap token with a ttl of 12 hours
kubeadm token create --ttl {{12h0m0s}}
# check if the kubernetes cluster is upgradeable and which versions are available
kubeadm upgrade plan
# upgrade kubernetes cluster to a specified version
kubeadm upgrade apply {{version}}
# view the kubeadm configmap containing the cluster's configuration
kubeadm config view
# revert changes made to the host by 'kubeadm init' or 'kubeadm join'
kubeadm reset
# initialize a new or existing terraform configuration
terraform init
# verify that the configuration files are syntactically valid
terraform validate
# format configuration according to terraform language style conventions
terraform fmt
# generate and show an execution plan
terraform plan
# build or change infrastructure
terraform apply
# destroy terraformmanaged infrastructure
terraform destroy
# split a file, each split having 10 lines (except the last split)
split -l {{10}} {{filename}}
# split a file into 5 files. file is split such that each split has same size (except the last split)
split -n {{5}} {{filename}}
# split a file with 512 bytes in each split (except the last split; use 512k for kilobytes and 512m for megabytes)
split -b {{512}} {{filename}}
# split a file with at most 512 bytes in each split without breaking lines
split -C {{512}} {{filename}}
# list all properties in one's active configuration
gcloud config list
# log in to google account
gcloud auth login
# set the active project
gcloud config set project {{project_name}}
# ssh into a virtual machine instance
gcloud compute ssh {{user}}@{{instance}}
# display all google compute engine instances in a project. instances from all zones are listed by default
gcloud compute instances list
# update a kubeconfig file with the appropriate credentials to point kubectl to a specific cluster in google kubernetes engine
gcloud container clusters get-credentials {{cluster_name}}
# update all gcloud cli components
gcloud components update
# show help for a given command
gcloud help {{command}}
# create an image from a specific container
docker commit {{container}} {{image}}:{{tag}}
# apply a `cmd` dockerfile instruction to the created image
docker commit --change="CMD {{command}}" {{container}} {{image}}:{{tag}}
# apply an `env` dockerfile instruction to the created image
docker commit --change="ENV {{name}}={{value}}" {{container}} {{image}}:{{tag}}
# create an image with a specific author in the metadata
docker commit --author="{{author}}" {{container}} {{image}}:{{tag}}
# create an image with a specific comment in the metadata
docker commit --message="{{comment}}" {{container}} {{image}}:{{tag}}
# create an image without pausing the container during commit
docker commit --pause={{false}} {{container}} {{image}}:{{tag}}
# display help
docker commit --help
# list sessions
abduco
# attach to a session, creating it if it doesn't exist
abduco -A {{name}} {{bash}}
# attach to a session with `dvtm`, creating it if it doesn't exist
abduco -A {{name}}
# detach from a session
Ctrl + \
# attach to a session in readonly mode
abduco -Ar {{name}}