
Ask HN: Best Command-Line Applications? - jaydouken
I really enjoy using a command-line interface instead of a graphical user interface, and was wondering if anyone had any solid recommendations for applications that one can use in a terminal window.
======
codychan
Tmux: [https://github.com/tmux/tmux/](https://github.com/tmux/tmux/)

fish-shell: [https://github.com/fish-shell/fish-
shell/](https://github.com/fish-shell/fish-shell/)

ranger: [https://github.com/ranger/ranger/](https://github.com/ranger/ranger/)

tig: [https://github.com/jonas/tig/](https://github.com/jonas/tig/)

ag or rg:
[https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

And all my configurations, especially for fish-shell:
[http://github.com/c02y/dotfiles](http://github.com/c02y/dotfiles)

~~~
vanderZwan
I love fish-shell, but after years of using it I switched to _Oh My ZSH!_. The
bash compatibility makes it a whole lot easier to use when you're the type of
person who has to look up "how to do X on the command line" on the internet
more often than you'd like to admit (that would be me).

[https://ohmyz.sh/](https://ohmyz.sh/)

~~~
ComputerGuru
fwiw, we are shipping a number of features in fish 3.0 (any day now!) that are
specifically targeting at maximizing compatibility with most bash scripts
(still not POSIX).

That includes support for && and || and a few other things that should go a
long way towards making most code you find drop-in ready.

~~~
explainplease
Really? Doesn't that go against the stated fish design document and
ridiculousfish's intention for fish?

I'm more concerned about making fish scripts work well than making fish run
bash scripts. (Maybe fish 3.0 will improve that too.) I've tried to use fish
for writing somewhat serious scripts several times, and I've always run into
frustrating problems that sent me back to bash for scripting. Fish is an
excellent interactive shell, of course.

~~~
ComputerGuru
You can see the discussions on GitHub but @ridiculousfish authored that series
of commits fwiw.

However with regards to your other matter, I personally just finished
rewriting the job control code to close out a lot of long standing bugs
affecting correctness and child process behavior in complicated scripting
cases, and other members like @faho have done an amazing job fixing up some of
the builtins and scripting-related improvements as well as putting in insane
effort into the interactive behavior of the shell and its insane library of
completions.

Try the current fish master builds and see how if fares. If you have any
specific concerns, please file a GitHub issue. It’s an open source project and
it can only succeed with the help of the entire community.

fwiw I find the sanity fish brings to process substitution with sane
tokenization and automatic escaping of shell substitution output to be a huge
boon to productivity over writing in (ba)sh. These days, my scripts are either
written in ninja or bmake if they are rule/output driven or fish otherwise.

~~~
explainplease
Thanks for the updates. I have contributed to related discussions on GitHub
for several years, but I haven't been able to keep up with all the issues.

> fwiw I find the sanity fish brings to process substitution with sane
> tokenization and automatic escaping of shell substitution output to be a
> huge boon to productivity over writing in (ba)sh.

I completely agree, this is why I would much prefer to use fish for scripting
when feasible. I'm glad to hear that the scripting is being improved.

------
artwr
A few of the ones I use almost daily

\- Pandoc a handy document format converter:
[https://pandoc.org/](https://pandoc.org/) \- Ripgrep, a faster grep:
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)
\- There are quite a few prompt-toolkit based CLI which have been really nice:
* mycli ([https://github.com/dbcli/mycli](https://github.com/dbcli/mycli)),
pgcli ([https://github.com/dbcli/pgcli](https://github.com/dbcli/pgcli)) *
ptpython/ptipython ([https://github.com/prompt-
toolkit/ptpython](https://github.com/prompt-toolkit/ptpython)) \- Youtube-dl:
[http://rg3.github.io/youtube-dl/](http://rg3.github.io/youtube-dl/) \- fzf a
fuzzy finder for the console:
[https://github.com/junegunn/fzf](https://github.com/junegunn/fzf) \- jq for
JSON manipulation:
[https://stedolan.github.io/jq/](https://stedolan.github.io/jq/) \- Miller for
CSV/TSV:
[https://github.com/johnkerl/miller](https://github.com/johnkerl/miller)

I would imagine you have already scoured the "awesome" lists:
[https://github.com/agarrharr/awesome-cli-apps#terminal-
utili...](https://github.com/agarrharr/awesome-cli-apps#terminal-utilities)

~~~
egze
Wow. mycli and pgcli are so good!

~~~
h1d
It is. Omitting the semi colon to execute a statement alone feels good.

------
Dowwie
Just about every Rust cli app written by sharkdp:

    
    
        https://github.com/sharkdp/fd
        https://github.com/sharkdp/bat
        https://github.com/sharkdp/diskus
        https://github.com/sharkdp/hyperfine
    

For viewing csv's as tabular, paged data from the terminal, check out VisiData
(python)
[https://github.com/saulpw/visidata](https://github.com/saulpw/visidata)

~~~
qorrect
| For viewing csv's as tabular

I use peco for this
[https://github.com/peco/peco](https://github.com/peco/peco) , thanks for
sharkdp checking those out.

~~~
Dowwie
How are you using peco to view csv's?

------
rutierut
Ngrok - [https://ngrok.com](https://ngrok.com)

So easy and super convienient if you quickly need your local server accessible
from somewhere else.

~~~
npstr
This one is even easier because it doesn't require to install anything, just
make a good old ssh tunnel: [http://localhost.run](http://localhost.run)

~~~
jakelazaroff
The thing I really love about ngrok, though, is the web dashboard where you
can inspect your tunnelled traffic and even replay requests:
[https://ngrok.com/docs#inspect](https://ngrok.com/docs#inspect)

------
inp
Nice question!

Here my personal setting:

\- Email : mutt [[http://www.mutt.org/](http://www.mutt.org/)]

\- Passwords manager : pass
[[https://www.passwordstore.org/](https://www.passwordstore.org/)]

\- Navigate directories : autojump
[[https://github.com/wting/autojump](https://github.com/wting/autojump)]

\- Task manager : task [[https://taskwarrior.org/](https://taskwarrior.org/)]

\- Music : cmus [[https://cmus.github.io/](https://cmus.github.io/)]

\- Text editor : emacs -nw
[[https://www.gnu.org/software/emacs/](https://www.gnu.org/software/emacs/)]

~~~
libdjml
Excuse my very basic question, but how do you manage spam when using mutt? Do
you interface to a cloud-based service in mutt, or have some kind of other
spam filter?

I’ve always liked the idea of moving my email to mutt and using personal
domains, but not convinced I could manage spam well.

~~~
em-bee
the same way you manage it with a GUI mail client. if you use a mailservice
that includes a spam-filter, you can use mutt's imap support to access it, and
thus access the filtered mailbox like any GUI or webmail client would.

for your own personal domain, either use a service that supports
personalization. (gmail does, but there should be others) and you are covered
again.

if you want to host your own mail server, then you'll probably want to run
your own spam filter on that server. it works by having the mail server
forward the mail to the filter (which can be local or remote) and then deal
with the mail based on the response from the service.

greetings, eMBee.

------
skrebbel
Scoop - [https://scoop.sh](https://scoop.sh)

It's basically apt/brew on Windows, but it's particularly awesome because it
does _not_ manage dependencies. It just downloads and extracts installers,
which works because every self-respecting program that works on Windows
distributes binaries as an installer (or just a zip) somewhere. Result:
everything just works, every program is self-contained, no admin rights
needed, no package maintainers needed either.

~~~
superasn
So far I've been using Chocolatey
([https://chocolatey.org](https://chocolatey.org)) for doing this (and ninite
though that's not command line). But this looks pretty cool too. Thanks for
sharing!

~~~
PhilippGille
I created a small CLI tool that I package for Homebrew, Snap, Docker,
Chocolatey and Scoop, and I prefer the packaging experience for Scoop, which
is the most easy and straightforward one.

Compare the respective directories in
[https://github.com/philippgille/serve](https://github.com/philippgille/serve).

~~~
skrebbel
Nice tool btw! I wish I'd known about it 5 days ago, when I taught a class
that involved a little bit of web development. I used devd, but getting it in
the PATH was a non trivial task for some of the trainees who used Windows.
Serve has an installer, which presumably solves that even without scoop or
chocolatey.

------
xelxebar
Cli-junkie brofist! I only drop out of the command line for occasional one-off
browser stuff.

Depending on your current familiarity with things, I can't recommend enough
simply combing through the tools in _coreutils_ , _util-linux_ , _find-utils_
etc. If you take just three or so a day, by the end of a few months you'll
have a solid survey-understanding of what almost every *nix shell has
available.

Apart from that, here are some I use and enjoy:

[0]:[http://abook.sourceforge.net/](http://abook.sourceforge.net/) \-- Vintage
address book; Plays well with mutt

[1]:[http://git-annex.branchable.com](http://git-annex.branchable.com) \-- A
better Dropbox, and via git!

[2]:[https://www.lesbonscomptes.com/recoll/](https://www.lesbonscomptes.com/recoll/)
\-- Index and search the contents and metadata of (pdf, word, etc) documents

[3]:[https://www.roaringpenguin.com/products/remind](https://www.roaringpenguin.com/products/remind)
\-- Vintage and sophisticated tool for doing calendrical stuff.

[4]:[https://github.com/trizen/youtube-
viewer](https://github.com/trizen/youtube-viewer) \-- CLI YouTube with all the
bells and whistles!

[5]:[https://6xq.net/pianobar/](https://6xq.net/pianobar/) \-- Pandora radio!

~~~
vanderZwan
> _git-annex is not a filesystem or Dropbox clone. However, the git-annex
> assistant is addressing some of the same needs in its own unique ways.
> (There is also a FUSE filesystem built on top of git-annex, called
> ShareBox.)_

So I assume you made it work like Dropbox for you anyway. How did that go?

~~~
xelxebar
The "a better Dropbox" comment was quite tongue in cheek. You can think of
git-annex as a way of managing files in git without managing the contents,
which is exactly what we want for binary blobs like PDFs, word documents,
whatever.

The syncronization between computers is done essentially how one would do it
with git. Personally, I sync to a private VM host so the content is available
"in the cloud".

At the moment I just sycn everything manually, but it's possible to setup git-
hooks to make it automatic. git-annex is nice for power users, since it allows
fine grained control of where to keep what content. The file metadata is
stored in git, but you choose when and how to pull or push the actual files
themselves.

That makes it possible to sync cross sections of an entire library, for
example. This is how I manage what to put on my kindle and what to keep off
it.

~~~
cliffwarden
There is git-annex assistant. I ended up going back to manual synchronizing,
but it is promising as more of a drop-in replacement for DB.

[https://git-annex.branchable.com/assistant/](https://git-
annex.branchable.com/assistant/)

------
joshbaptiste
Tmux: [https://github.com/tmux/tmux/](https://github.com/tmux/tmux/)

ts:
[http://vicerveza.homeunix.net/~viric/soft/ts/](http://vicerveza.homeunix.net/~viric/soft/ts/)
(TaskSpooler) queue commands in different terminals

socat: [http://www.dest-unreach.org/socat/](http://www.dest-
unreach.org/socat/) \-- Multi-purpose relay

most: [http://www.jedsoft.org/most/](http://www.jedsoft.org/most/) pager more
features than less/more

sshfs: [https://github.com/libfuse/sshfs](https://github.com/libfuse/sshfs)
remote filesystem using SFTP via FUSE

passgo: [https://github.com/ejcx/passgo](https://github.com/ejcx/passgo)
Simple golang password manager

rclone: [https://github.com/ncw/rclone](https://github.com/ncw/rclone) rsync
for cloud storage

autosub:
[https://github.com/agermanidis/autosub](https://github.com/agermanidis/autosub)
Command-line utility for auto-generating subtitles for any video file

~~~
h1d
If you want more complete cloud backup, try restic or duplicacy which have
encryption, dedup and retention policy.

[https://github.com/restic/restic](https://github.com/restic/restic)

[https://github.com/gilbertchen/duplicacy](https://github.com/gilbertchen/duplicacy)

~~~
rraghur
Also, I found borg better than restic since borg also does compression

[https://github.com/borgbackup/borg](https://github.com/borgbackup/borg)

~~~
h1d
The author is willing to add compression to restic but that was in March and
no ETA.

[https://github.com/restic/restic/issues/21](https://github.com/restic/restic/issues/21)

~~~
rraghur
Thanks - I'm subbed to that ticket. Will most likely switch over when it's
done since a I vastly prefer a single binary rather than having to install
python + deps.

------
lozf
Some great contributions here ... some that are missing (or at least scarce)
which deserve more attention:

units - for a broad range of conversions without having to resort to Wolfram
Alpha or a search engine

bc -l - the -l option really empowers this awesome little calculator.

mpv - awesome media player - point it at a media URL (it uses youtube-dl in
the background, so perfect for viewing or listening with no ads,) but can also
play from open directories / SMB shares, online radio, Play a series of images
as video, Access any FFmpeg/Libav libavformat protocol or filter (including
generating tones and images, and more. And once it's playing, has great
interactive keyboard controls for many useful functions.

~~~
vram22
>Some great contributions here ...

Agreed.

>bc -l - the -l option really empowers this awesome little calculator.

Right. Since bc is a Unix filter, you can also pipe expressions into it, to be
evaluated, so it can be used in general Unix pipelines. E.g.:

    
    
      echo *arithmetic_expression* | bc -l
    

and the output comes on stdout, so it can be further piped.

Edit: You have to quote any shell special characters in
_arithmetic_expression_ with single quotes, or better, just enclose the entire
_arithmetic_expression_ in single quotes. If asterisk (for multiplication) is
not quoted, for example, it will be treated as a filename wildcard instead,
and likely lead to an error. A wrong and a right example:

    
    
      $ echo 2 + 3 * 4 | bc -l
      (standard_in) 1: syntax error
    
      $ echo '2 + 3 * 4' | bc -l
      14

------
fiddlerwoaroof
For working on servers, tmux + mosh is a killer combination: mosh makes your
connection resilient to network issues and tmux gives you (back) scrollback
and cross-session persistence.

mutt is hard to beat as an email client and circe (an emacs package) + znc on
a digital ocean instance or equivalent makes for a great persistent irc
session.

~~~
ianai
Mosh also makes it possible to have an ssh client running on a mobile device
and still use the mobile device as a mobile.

------
ivan_ah
youtube_dl an ffmpeg would be my top two in terms of power.

Here are my top commands by frequency of use:

    
    
        4421 git
         952 open
         936 vim
         908 cd
         603 ls
         566 grep
         533 cp
         429 rm
         414 mv
         250 atom
         247 pip
         233 mkdir
         223 fab
         163 docker
         130 touch
         128 find
         123 youtube-dl
         113 python
         103 ssh
         100 cat
          99 wget
          81 pytest
          75 brew
    

total is of ~16k history lines... this means one in ever 4 commands I type is
git! Wow I didn't know that. Probably `git status`...

~~~
adtac
I use git so much that I made these aliases in zsh:

    
    
        alias g="git show"
        alias gh="git show HEAD"
        alias gs="git status"
        alias gl="git log"
        alias gco="git checkout"
        alias gd="git diff"
        alias gbl="git branch -v"
        alias gbd="git branch -D"
        alias gri="git rebase --interactive"
        alias grc="git rebase --continue"
        alias gra="git rebase --abort"
        alias gst="git stash"
        alias gsta="git stash apply"
        alias gx="gco -- \*; git reset HEAD \*"
        alias gcp="git cherry-pick"
        alias gcpc="git cherry-pick --continue"
        alias gcpa="git cherry-pick --abort"
    

A few hundred instances of "gs" in my .zhistory :)

~~~
klatys
nice ones! couple from my bash_alias

    
    
        alias ..="cd .."
        alias ..2="cd ../.."
        # ... you get the idea, mine goes up to 5
        function mkcd () { mkdir -p "$@" && eval cd "\"\$$#\""; }
        alias h="history|grep"

~~~
bpmckenna
Instead of your `..` aliases, I have this, which saves some copy-pasting.

    
    
        function up() { cd "$(printf '../'%.0s $(seq 1 "${1:-1}"))" && pwd; } #up 4 goes up 4 directories

------
adtac
rg (ripgrep):
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

I used to use ag (the silver searcher) [1] before, and `ag` was practically a
muscle memory to me, but then I came across ripgrep and it was so much faster.
I've now installed a static binary of ripgrep in every machine I have SSH
access to.

[1]
[https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)

~~~
petdance
Note that rg and ag don't have the same feature sets. Here's a handy chart
that shows the differences.

[https://beyondgrep.com/feature-comparison/](https://beyondgrep.com/feature-
comparison/)

~~~
burntsushi
That chart is now quite out of date. I don't think there are any substantial
features present in ag that are absent from rg. See my note in the README:
[https://github.com/BurntSushi/ripgrep#feature-
comparison](https://github.com/BurntSushi/ripgrep#feature-comparison)

~~~
petdance
Please let me know what's new so that I can update the chart. Dumping into an
issue will do, and then I can worry about getting it into chart format.

[https://github.com/beyondgrep/website/issues](https://github.com/beyondgrep/website/issues)

------
stevewillows
I use the following (in no particular order) -- definitely nothing fancy.

* weechat

* ffmpeg

* youtube-dl

* zsh

* watchman ([https://facebook.github.io/watchman](https://facebook.github.io/watchman))

* megadl (rarely, but its a handy tool when you need it)

* brew (on my mac)

* mountsshfs (on my mac)

\---

I moved away from orgmode and have been using it in VS since I have it open
anyway. It covers me.

I also want to start using Mutt or something similar.

For those wondering, you can output an unnecessarily pretty list using:

    
    
        history | tr -s ' ' | cut -d ' ' -f3 | sort | uniq -c | sort -n | tail | perl -lane 'print $F[1], "\t", $F[0], " ", "" x ($F[0] / 12)'

~~~
tummybug
This doesn't look to take commands after a pipe into account so IMHO doesn't
accurately reflect command usage. For example running above I was surprised
awk wasn't in the list but when I went to investigate I found I almost always
am piping something to awk.

~~~
yesenadam
Hmm yeah. And often I type multiple commands separated by semicolons, which it
bunches together as one. Also that and long paths meant mine was very
unpretty. Speaking of AWK, this uses the same flawed method, looks nicer (for
my history), and is shorter:

    
    
      history | awk '{a[$2]++} END{for (i in a) print a[i]"\t"i}' | sort -n | tail

------
pxc
This is an abbreviated list of my command-line applications, taken from the
Nixpkgs overlay I use for configuring macOS, NixOS, and non-NixOS Linux:

    
    
      pxc.common.tui.pkgs = with self.pkgs; [
        # cli basics
        htop                # top, but nicer
        httpie              # curl, but much nicer except for lacking a man-page (--help is very complete)
        ranger              # file manager
        ripgrep             # my favorite grep alternative/replacement
        tree                # prints directory trees
    
        # stuff my fish config uses and some goodies I want
        fish                # very nice shell, replaces bash
        grc                 # GNU regular colorizer: uses regular expressions to colorize the terminal
        tmux                # terminal multiplexer (tiling window manager for the terminal)
        byobu               # some tmux config that makes things a little nicer. Great for new tmux users, hardly used anymore
        fzf                 # fuzzy filtering: used for changing directories, selecting files to open, browsing shell history
        fasd                # frecency tools: jump to directories, open files, etc., based on fuzzy matches sorted by frecency
        keychain            # simplified SSH and GPG key loading/management
        direnv              # barebones projects, pretty nifty
        gitAndTools.hub     # GitHub CLI extensions for Git
        gitAndTools.tig     # curses TUI for browsing git logs
    
        # makes tmux pretty with `powerline-config tmux setup`
        pythonPackages.powerline
        findutils           # macOS comes with weak find command
        gawk                # macOS comes with ancient gawk, tmux-fingers wants a newer one
    
        pass                # GPG+git-based CLI password manager
        pwgen               # for use with pass
    
        p7zip               # archiving tool that can do pretty much everything
    
        # chat
        weechat             # nice terminal-based IRC app
    
        ### extras-ish ###
        mediainfo           # tell me things about multimedia files
        asciinema           # record TTY/terminal sessions (with audio) as moving text for the browser
        cowsay
        graphicsmagick      # image manipulation. lots of fun for quickly uploading custom emoji to Slack
      ];

------
b3b0p
I've been digging ncdu recently, which is basically a du replacement:
[https://dev.yorhel.nl/ncdu](https://dev.yorhel.nl/ncdu)

~~~
jyounker
Ncdu is _really_ useful for identifying space hogs.

~~~
mav3rick
+1. Really really handy.

------
cjoelrun
Music organizer/player [http://beets.io](http://beets.io)

File browser
[https://github.com/ranger/ranger](https://github.com/ranger/ranger)

Emacs - It does anything you want.

Emacs If you like vim keys bindings -
[http://spacemacs.org](http://spacemacs.org)

Terminal multiplexer - Tmux

~~~
catacombs
Another alternative to Emacs with vim keybindings is Doom Emacs. It's superior
to Spacemacs imo.

~~~
suprfnk
I've been using Spacemacs for a while, what sets Doom Emacs apart?

~~~
colelyman
I am a convert from Spacemacs to Doom, and I have found that one of the main
differences that sets Doom apart is easier configurability than Spacemacs. In
Doom, there is still the concept of "layers," but IMO it is much easier to
figure out what the layers are doing and customize them from there.

Also, I have found Doom to be much quicker (takes about 2 seconds to load, not
using server/client) and less buggy than Spacemacs. I would highly recommend
giving Doom a try!

~~~
catacombs
This. Also, the developer is responsive on his Discord server should you have
any issues with the editor. Henrik is patient, kind and reliable, rare traits
for open source projects these days.

~~~
colelyman
I completely agree, I have had a very similar experience with Henrik.

------
zornado
Aria2: [https://github.com/aria2/aria2](https://github.com/aria2/aria2) an
excellent download manager. Supports many functionalities such as downloading
torrents, multi-connection downloads, and resuming uncompleted downloads. It
also support RPC calls which enables it to be an excellent download manager
back-end.

~~~
SegFaultCDumped
I saw Aria2 has two packages in F-driod. I installed them and looked at the
docs but I couldn't figure out how to download stuffs with Aria2. A small
example of it's use will be highly appreciated. Thank you.

~~~
efreak
you need both. One of them pnly supplies a UI, while the other only supplies
the binary. I personally recommend running aria2c via termux and using
ziahamza.github.io/webui-aria2

------
IgorrrR
I became addicted to these great tools all written in Rust:

fselect -
[https://github.com/jhspetersson/fselect](https://github.com/jhspetersson/fselect)

ripgrep -
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

exa - [https://the.exa.website](https://the.exa.website)

They are the replacements for traditional find, grep, and ls.

~~~
callahad
I suspect you'd also enjoy fd -
[https://github.com/sharkdp/fd](https://github.com/sharkdp/fd)

------
donatj
vim

It's really worth the time to learn. It's pre-installed basically everywhere,
it's amazingly useful. It has the features of a modern text editor all in a
command line.

~~~
amelius
Vim is an interactive application.

~~~
nurettin
so is less

~~~
amelius
Both are not command line tools, imho.

------
ScarZy
I use vim exclusively, and use a terminal for most things.

FZF - fuzzy file finding lightning quick, I use this as a ctrl+p replacement
in vim too. Kubectx - Supported by FZF. Quickly change k8s context and define
namespaces easily too (Kubens)

------
mdip
There are so many to list that I'll skip the more obvious ones (they're well
represented in the comments) and pick a few that I've been enjoying _a lot_
lately:

Netflix-Skunkworks/go-jira[0] - Jira interface written in Go that is
incredibly flexible.

bat[1] - cat with code highlighting

climate[2] - Shell swiss-army knife of tools

That last one deserves a post on its own. It's certainly not the most portable
thing -- requiring that certain binaries be available for some of its
functions, but it works as-is for the Linux distributions that I run and
provide simple commands for getting information about things that isn't always
trivial to remember (such as getting an external IP address of a host from the
command-line). Silly things like remembering the CLI options for 'du' (along
with the necessary '| sort ... | head -5') are replaced by 'climate biggest-
files'. It replaces a _mess_ of tools, but does so, often, by simply calling
those tools with the "correct" parameters that I've forgotten.

Yes, a well authored set of aliases for the most common commands would do the
same thing, but I end up using 'climate' in cases where the information I need
is something I _rarely_ need for a given task and getting that information is
going to be a non-obvious exercise involving a few pipes. It's a "kitchen
sink" utility with a set of commands that, for the most part, you'd find a
hard time grouping them into a single theme -- a command for getting the
current weather (after all, it is named _climate_ ) next to one to download
all files on a web page, next to one to get disk usage stats in a variety of
ways. Normally, I don't like tools like this, but this one lands as a big
exception to that rule for me.

[0] [https://github.com/Netflix-Skunkworks/go-
jira](https://github.com/Netflix-Skunkworks/go-jira)

[1] [https://github.com/sharkdp/bat](https://github.com/sharkdp/bat)

[2] [https://github.com/adtac/climate](https://github.com/adtac/climate)

~~~
Aweorih
> such as getting an external IP address of a host from the command-line.

What about using `ping host`? This also prints the ip

~~~
mdip
Ah, sorry, I wasn't clear in my statement:

A function that it provides is to display the public IP address from a host
behind the NAT.

Another way to do this: `dig @resolver1.opendns.com ANY myip.opendns.com
+short`[0] ... it's just trickier to remember. And since dig is a tool for
performing DNS lookups, `man dig` doesn't hint at this particular trick.

In fact, I didn't actually remember the command that displays that for
`climate`[1], because if I had, I would have written it as `public-ip`, which
`climate help` informed me of. :)

[0] ... or if you prefer a more interactive and profane experience, try `lynx
wtfismyip.com`

[1] My public IP is displayed on terminal start since I need it with some
frequency; Of course, it's displayed as "External IP:", which is something
I'll have to remedy.

------
binaryapparatus
[https://newsboat.org/](https://newsboat.org/) Newsboat, fantastic RSS reader,
built on top of newsbeuter.

[http://www.mutt.org/](http://www.mutt.org/) Mutt for email of course.

[https://vifm.info/](https://vifm.info/) Vifm file manager, I am using it for
everything, not having any other file manager on my system.

[https://github.com/pimutils/khal](https://github.com/pimutils/khal) Khal for
calendar.

[https://github.com/scheibler/khard/](https://github.com/scheibler/khard/)
Khard for contacts.

[https://github.com/pimutils/vdirsyncer](https://github.com/pimutils/vdirsyncer)
Vdirsyncer to sync calendar and contacts with any web calendar service.

~~~
stevekemp
Mutt is great, but if you want to use a "real" programming language to
configure your client you might enjoy my alternative:

[https://lumail.org/](https://lumail.org/)

[https://github.com/lumail/lumail/](https://github.com/lumail/lumail/)

~~~
em-bee
it's nice to see new approaches to email in a terminal. how about integration
with notmuch?

greetings, eMBee.

~~~
stevekemp
I think the people that enjoy notmuch would probably prefer to stick with what
they know.

If I were to use their query-based API, and just be a UI on it, then that'd be
an almost complete rewrite.

~~~
em-bee
on the contrary for the first point. i suspect that most enjoy notmuch with
their traditional interface because there are not many alternatives. probably
most people looking for interface alternatives switched to gmail.

commandline UI development in particular seems very conservative, and attempts
to explore new interfaces are rare. that's why i love this topic and am
getting excited about any attempt to change that.

i obviously can't comment on what it takes to integrate notmuch with lumail,
and i grant that one may possibly have to develop a mailclient with notmuch in
mind for it to work well.

greetings, eMBee.

------
agentultra
I love `jq`: [https://stedolan.github.io/jq/](https://stedolan.github.io/jq/)

------
scrollaway
httpie is the nonstandard command I use the most I think
([https://httpie.org/](https://httpie.org/)). Syntax highlighting for
everything that comes down the pipe is pretty awesome. I'm also a sucker for
bat ([https://github.com/sharkdp/bat](https://github.com/sharkdp/bat)) which I
just found out about through this thread.

My zshrc includes a bunch of commands you might like, btw:
[https://github.com/jleclanche/dotfiles](https://github.com/jleclanche/dotfiles)

Among them, the ones I use the most are `json` and `yaml` for pretty printing
both formats, as well as `urlencode` / `urldecode` / `urlarray` which I
recently added.

------
thelibrarian
If you need to handle XML, xmlstarlet
([http://xmlstar.sourceforge.net](http://xmlstar.sourceforge.net)) is
fantastic, and much more powerful than the standard line-oriented tools like
sed and awk for this task.

Similarly jq
([https://stedolan.github.io/jq/](https://stedolan.github.io/jq/)) for JSON
data is great.

~~~
CJKerr
And to round out the set, xsv
([https://github.com/BurntSushi/xsv/](https://github.com/BurntSushi/xsv/)) is
a powerful toolkit for CSV.

------
bobfromhuddle
* Email - neomutt + notmuch.

* Chat - Weechat + WeeSlack ([https://github.com/wee-slack/wee-slack](https://github.com/wee-slack/wee-slack))

* Pair Programming - tmate.io + neovim

* Google Play Music - tuijam([https://github.com/cfangmeier/tuijam](https://github.com/cfangmeier/tuijam))

I really like bat
([https://github.com/sharkdp/bat](https://github.com/sharkdp/bat)) as a cat
replacement, and I've been enjoying using entr
([http://entrproject.org/](http://entrproject.org/)) for running tests
automatically when code changes.

------
mike_r_parsons
websocketd - Turn any command that uses stdin into a web socket server (i.e.
connect to it from any browser)
[https://github.com/joewalnes/websocketd](https://github.com/joewalnes/websocketd)

sqlite shell -
[https://www.sqlite.org/download.html](https://www.sqlite.org/download.html)

combine the two for a high throughput web app -
[https://hackernoon.com/stream-a-million-websocket-sql-
reques...](https://hackernoon.com/stream-a-million-websocket-sql-requests-
from-a-single-browser-client-in-a-few-seconds-e7a2b068974c)

~~~
vram22
I had blogged about websocket with an example using Python and JavaScript
here:

Use WebSockets and Python for web-based system monitoring:

[https://jugad2.blogspot.com/2014/01/use-websockets-and-
pytho...](https://jugad2.blogspot.com/2014/01/use-websockets-and-python-for-
web-based.html)

websocketd and Python for system monitoring - the JavaScript WebSocket client:

[https://jugad2.blogspot.com/2014/01/websocketd-and-python-
fo...](https://jugad2.blogspot.com/2014/01/websocketd-and-python-for-
system.html)

Will check out your hackernoon post, sounds interesting.

~~~
vram22
I read that post. It's impressive that the combination of websocketd and
sqlite can be so fast.

------
thanksDr
Not exactly _useful_ , but it makes me smile every time I use it:
[https://github.com/will8211/unimatrix](https://github.com/will8211/unimatrix)

------
arsalanb
The Fuck — [https://github.com/nvbn/thefuck](https://github.com/nvbn/thefuck)

Magnificent app which corrects your previous console command

~~~
dewey
If you use zsh something like that is already included.

~~~
slenk
Typing fuck is satisfying though

------
zwischenzug
Always had a soft spot for 'hollywood'

[https://www.youtube.com/watch?v=rVMn3xk5mcY](https://www.youtube.com/watch?v=rVMn3xk5mcY)

------
deanmoriarty
rsync. It’s installed everywhere and makes it super easy to keep source code
in sync between laptop and remote servers. It’s so fast that I completely
ignore more advanced solutions based on fanotify or similar, and literally
include rsync before every “build/run” command during development.

------
benp44
I wrote a Python cli tool for getting the git status/history over multiple
local repositories. I am often working across several repos on a single
project, but generally I find it useful to see what updates are available, and
also what my team are up to.

[https://github.com/benp44/git-bulk-toolkit](https://github.com/benp44/git-
bulk-toolkit)

 _shameless plug alert_

~~~
fiveFeet
I use mr [1] for this

[1] - [https://myrepos.branchable.com/](https://myrepos.branchable.com/)

------
pjs_
I love _watch_.

    
    
      watch df -h
      watch ls -sh
      watch cat file
      watch nmcli device wifi list
      watch -n 10 --color curl -s wttr.in

~~~
ianai
I think I remember combining watch with tail before...not sure why since -f
keeps a stream open.

~~~
dijit
Tail -f works by opening the file and remembering the byte offset, if it’s a
log file that gets flushed/wiped then tail -f won’t see anything until the
logs fill enough to exceed the previous file contents.

~~~
stevekemp
True, but the `-F` flag will work in that case.

~~~
dijit
TIL

Works on BSD `tail` too. :)

------
jodrellblank
If you aren't using tmux or screen, you probably should be, especially over
SSH sessions. They allow you to have multiple consoles open and switch between
them, split window, and disconnect from SSH and then reconnect with all your
things still open and running (as long as the server stayed running).

~~~
spondyl
As someone who hasn't invested much time into tmux/screen, what are the
benefits of it over just using eg; multiple terminal tabsn or using the
terminal's built in split windowing? I'm sure there's probably a benefit but I
dunno what it is

~~~
pjungwir
I agree with everyone else that it's great on remote systems, but the reason I
use it locally too is because I can set up all a project's "tabs" with just
one command. I have dozen-line scripts for each client/project that will
either create or attach to a tmux session, and when creating set up all the
windows how I want: setting their names, cd'ing, opening psql, tailing a log,
changing the bottom color (green for development, yellow for staging, red for
production), etc. For Rails work I typically have separate windows for models,
controllers, views, stylesheets, and javascripts. It makes it really easy to
get started after a reboot, or just hide projects for a while and bring them
back quickly.

~~~
em-bee
occasionally i need to restart the GUI. using tmux locally is very helpful for
that. also sometimes i log into my workstation from remote, like when i am
travelling. it's nice to be able to access the running session.

------
inp
A bunch of references from Suckless community that you can enjoy:

[http://suckless.org/rocks/](http://suckless.org/rocks/)

------
anjakefala
Open-source tool for quickly opening and exploring tabular data:
[https://jsvine.github.io/intro-to-
visidata/index.html](https://jsvine.github.io/intro-to-visidata/index.html)

(Disclaimer: I build homebrew, apt, etc packages for VisiData.)

~~~
roadnottaken
tabview [1] is a somewhat simpler tool for navigating tabular data that I
install everywhere

[https://pypi.org/project/tabview/](https://pypi.org/project/tabview/)

------
ohiovr
Goaccess is a great little realtime log file analyzer in a similar vein as
webalizer. Not only does it work through the console it can also output html.

[https://goaccess.io](https://goaccess.io)

(this is just something I found recently, not affiliated with it or anything)

------
dspillett
Three tools I make sure are installed on everything I use via CLI: rsync, pv,
& progress.

rsync (usually over SSH): the kitchen sync of file transfer commands. In
Linux-land it is quite common to find it already installed, and if not it is
in the standard repos. Available for Windows too.

pv (pipeviewer,
[http://www.ivarch.com/programs/pv.shtml](http://www.ivarch.com/programs/pv.shtml)):
very useful for monitoring some classes of long-running process.

progress
([https://github.com/Xfennec/progress](https://github.com/Xfennec/progress)):
for similar reasons to pv, wanting to see how a long-running task (that isn't
giving its own progress information) is getting on.

------
modernerd
z - track most-used directories and jump to them

[https://github.com/rupa/z](https://github.com/rupa/z)

[https://github.com/jethrokuan/z](https://github.com/jethrokuan/z) (fish port)

~~~
aldanor
Used to use that but stopped after while, figured it's easier to just type a
name or alias/symlink it if it's used often -- then it's deterministic in a
non-interactive way, i.e. I can type it with my eyes closed and I know the end
result.

With tools like z I'll have to type less letters in the end but it requires
interaction, and interaction/attention is more expensive than keypresses, at
least in my world :)

------
C0d3r
Useful tool replacements that some people have already mentioned:

\- ls -> exa

\- cat -> bat

\- find -> fd

\- top -> htop -> glances

\- grep -> ack -> ag -> rg

\- hr (to draw a horizontal line in your terminal)

A lightning talk about them:
[https://youtu.be/hp-1plTKOqc?t=551](https://youtu.be/hp-1plTKOqc?t=551)

~~~
kippfe
A url link to each toll would be nice

------
mohitmun
Checkout command line based spreadsheet editor. sc-
im([https://github.com/andmarti1424/sc-im](https://github.com/andmarti1424/sc-
im)) if you are heavy vim user, you would definitely love it

------
hatsubai
If you do any bash/sh programming, I highly recommend shellcheck:
[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck)

~~~
spudlyo
Agreed, highly recommended. I dreaded writing shell scripts for the longest
time because of the weird syntax and many gotchas. Having emacs flycheck my
shell buffers with shellcheck gives me confidence that I'm not doing anything
stupid.

------
AsyncAwait
\-
[https://github.com/haskellcamargo/sclack](https://github.com/haskellcamargo/sclack)
to avoid using Slack's garbage desktop client

------
michaelmior
If I had to pick a single utility, it would be pv[0]. It's very simple, but I
find myself using it all the time. Basically you stick it in a pipeline of
commands to get a progress bar. The simplest usage is just to replace cat or
input redirection with a call to pv. Saves a lot of time when I can quickly
find out if the command I wrote is going to take 30 seconds or 30 minutes.

[https://www.ivarch.com/programs/pv.shtml](https://www.ivarch.com/programs/pv.shtml)

------
akavel
up - [https://github.com/akavel/up](https://github.com/akavel/up)

 _Ultimate Plumber is a tool for writing Linux pipes with instant live
preview_

It's a new CLI tool I've recently written, and it reached a Top 1 position on
HN just after the public release. It works with other classic CLI tools by
boosting the speed with which they can be composed together. It's especially
useful for quick exploration of logs, CSV files, and other text files or
pipelines.

~~~
nurettin
is it like less?

~~~
akavel
Um; I feel it's kinda as if you asked if a dog is like rhinoceros... How do I
even answer that? Simplest answer is: "no, it's not"; though if you squint
your eyes super hard, you could see some kind of vague resemblance, maybe?

Have you seen the readme? There's an animated gif showing how it works, and a
more detailed description.

~~~
nurettin
Yeah, have you seen the readme?

> interactively and incrementally explore textual data

Just like less.

> This is achieved by boosting any typical Linux text-processing utils such as
> grep, sort, cut, paste, awk, wc, perl, etc., etc., by providing a quick,
> interactive, scrollable preview of their results.

Yep, that's less.

> use PgUp/PgDn and Ctrl-[←]/Ctrl-[→] for basic browsing through the command
> output;

Sure that's not like less? You can even start searching results of a high
output command immediately after the pipe.

Apparently dogs aren't that different?

~~~
akavel
Ahahah, lol, ok, get it :D So, apparently I totally reinvented less, I concede
:)

To say even more, it's actually very much a _crippled_ less (not all of its
functions available!). With just one feature added, namely:

> in the input box at the top of the screen, start writing any bash pipeline;
> then press Enter to execute the command you typed, and the Ultimate Plumber
> will immediately show you the output of the pipeline in the scrollable
> window.

At least for me personally, it was _painfully_ worth reimplementing the
crippled less functionalities for this single little addition. Though I do
admit I felt the lack of the slash-to-search feature of less already yesterday
when using up...

And, to explain myself a bit, I really tried my best at explaining the tool in
the readme... it's just that I can't currently think of any better wording :(
If by any chance you had some idea/suggestion how you think I could improve
it, I'd be super eager to hear it! I'm kinda too deep in the trenches to be
able to look at it from a distance, so even seemingly obvious (to you)
comments (as the one with the comparison to less, after you explained it) are
sincerely valuable to me!

~~~
nurettin
I haven't used the command, but from what I understand, it is like a shell
with less-like interface that you can pipe to, and work on a copy of the
output stream.

~~~
nurettin
I guess one way to articulate what you are doing is building /up/ more
commands in a step by step fashion with immediate feedback. It is not
necessarily a bad thing, especially if processing or preparation times for the
input are long. However, you could also accomplish the same thing with a
smaller sample size and repeatedly applying your commands using a regular
shell instead of an interactive less.

------
INTPenis
I'm a cli junkie but I've gone from using very minimal tiling WMs to vanilla
Gnome. So I've stopped using bitlbee for example, but bitlbee is something I'd
use a lot in the days of 100% terminal.

It's an IRC proxy for other protocols like Skype or Slack.

I have no idea how it stands up today but I always liked the concept of having
one service that handled conversion of all the modern protocols to text based.

Other than that I think people have already given amazing recommendations so I
have nothing to add.

~~~
lunchables
Curious what made you leave tiling WMs? I think about switching back
occasionally, but still use dwm.

I also used to use bitlbee, but once AIM died I dropped it.

Slack dropped their irc gateway a while ago. I recommend wee-slack[1] which is
a weechat[2] python plugin that uses the Slack API instead of the old IRC
gateway, which also means it is a lot more feature rich than the IRC gateway
was.

1 - [https://github.com/wee-slack/wee-slack](https://github.com/wee-slack/wee-
slack) 2 - [https://weechat.org/](https://weechat.org/)

~~~
INTPenis
My focus has always been on being able to work without issue. Without OS
locking up or without tools malfunctioning.

Used to have laptops with 256MB RAM for example, or 1024x768 pixel resolution.
So I'd do anything to cram as much as possible into a tiny screen using as
little resources as possible.

Now my laptop has 8G of RAM and an i7 CPU at 2.5GHz and 4 virtual cores. On
top of that Linux and Gnome have made a lot of advances so it runs like a
dream and I can work without having ~100 lines of configuration in my WM.

More seamlessly go from my own to someone elses computer without forgetting
that caps lock is my Meta key. It all pretty much resembles Windows and Mac OS
more.

I just don't see any purpose with torturing myself using a minimal resource
desktop environment when I don't have to.

The main program is still gnome-terminal and tmux, I still do a majority of my
work there. Habitually use cli for as much as possible, even simple operations
that I could do in the Gnome file browser.

But I do it all with a vanilla Gnome configuration and I still don't miss a
thing.

------
gameswithgo
ripgrep like grep but faster
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

------
spondyl
It's probably not what you'd use often/at all but I recently was glad to
discover Google's import-mailbox-to-gmail[0] script.

Technically a CLI I suppose, it imports an mbox file into Gmail. I had
switched to G Suite and wanted to import some old emails. It took a while but
this did the trick!

[0]: [https://github.com/google/import-mailbox-to-
gmail](https://github.com/google/import-mailbox-to-gmail)

------
AJRF
tig

(That's git backwards)

It's a luxury and you don't need it if you use something like fugitive in vim,
but its a lovely little tool.

[https://github.com/jonas/tig](https://github.com/jonas/tig)

Think SourceTree but on the command line.

~~~
h1d
tig doesn't feel like SourceTree. It's not easy to just see list of changed
files from a commit to the next.

In that sense, lazygit is more navigation friendly.

------
pmlnr
daily-ish drivers of mine:

\- autossh -
[https://linux.die.net/man/1/autossh](https://linux.die.net/man/1/autossh)

\- sshfs -
[https://github.com/libfuse/sshfs](https://github.com/libfuse/sshfs)

\- pandoc -
[https://pandoc.org/installing.html](https://pandoc.org/installing.html)

\- exiftool -
[https://www.sno.phy.queensu.ca/~phil/exiftool/](https://www.sno.phy.queensu.ca/~phil/exiftool/)

\- htop - [https://hisham.hm/htop/](https://hisham.hm/htop/)

\- tmux -
[https://github.com/tmux/tmux/wiki](https://github.com/tmux/tmux/wiki)

\- rsync - [https://rsync.samba.org/](https://rsync.samba.org/)

\- midnight commander - [https://midnight-commander.org/](https://midnight-
commander.org/) (faster, than loop ing ls, cd .., ls)

Still trying to think about the others.

------
michaelmcmillan
nc - arbitrary TCP and UDP connections and listens

File transfer between machines:

    
    
        $ nc -l 1234 > filename.out
    

Using a second machine, connect to the listening nc process, feeding it the
file which is to be transferred:

    
    
        $ nc host.example.com 1234 < filename.in
    

Or a simple web server:

    
    
        $ while true ; do nc -l -p 1500 -c 'echo -e "HTTP/1.1 200 OK\n\n $(date)"'; done

~~~
xvilka
Try ncat from nmap - it has more features. And for some specific applications
- socat.

------
jac08h
Ledger is a simple tool to keep track of your expenses.

[https://www.ledger-cli.org/](https://www.ledger-cli.org/)

------
underyx
Oh, I wrote an article on this a while ago! It's mostly about smaller
utilities, not full-fledged apps. Also, I ws focusing on the ones that are
lesser known. Still could be useful for some: [https://code.kiwi.com/lesser-
known-tools-we-love-at-kiwi-com...](https://code.kiwi.com/lesser-known-tools-
we-love-at-kiwi-com-part-1-of-3-cli-79eb6d67a065)

------
em-bee
here is a nice selection by bryan lunduke:

[https://www.networkworld.com/article/3091139/linux/who-
needs...](https://www.networkworld.com/article/3091139/linux/who-needs-a-gui-
how-to-live-in-a-linux-terminal.html)

he lists:

email: alpine

webbrowser: w3m

editor: nano

wordprocessing: wordgrinder
[http://cowlark.com/wordgrinder/index.html](http://cowlark.com/wordgrinder/index.html)

audioplayer: cmus
[https://en.wikipedia.org/wiki/Cmus](https://en.wikipedia.org/wiki/Cmus)

instant messaging: finch and hangups
[https://developer.pidgin.im/wiki/Using%20Finch](https://developer.pidgin.im/wiki/Using%20Finch)
[https://github.com/tdryer/hangups](https://github.com/tdryer/hangups)

twitter: rainbowstream
[https://github.com/orakaro/rainbowstream](https://github.com/orakaro/rainbowstream)

reddit: rtv [https://github.com/michael-lazar/rtv](https://github.com/michael-
lazar/rtv)

ps: htop

filemanager: midnight commander

terminal manager: tmux

presentations: tpp
[http://www.ngolde.de/tpp.html](http://www.ngolde.de/tpp.html)

greetings, eMBee.

------
bklaasen
abcde - A Better CD Encoder
([http://lly.org/~rcw/abcde/page/](http://lly.org/~rcw/abcde/page/)) I bought
three cheap USB CD drives and concurrently ripped all of my CDs to FLAC over
the course of a couple of weekends. abcde gets the best possible copy.

ddrescue - GNU ddrescue
([https://www.gnu.org/software/ddrescue/](https://www.gnu.org/software/ddrescue/))
not to be confused with dd_rescue
([http://www.garloff.de/kurt/linux/ddrescue/](http://www.garloff.de/kurt/linux/ddrescue/))
This piece of software is outstandingly good for rescuing bits from failing
spinning rust. It doesn't care about the filesystem, it just tries really hard
to get data from a raw device. Once you've got all the bits onto a safer
medium, you can use testdisk to explore the disk image.

------
homarp
archiver:
[https://github.com/mholt/archiver](https://github.com/mholt/archiver) create
and extract .zip, .tar, .tar.gz, .tar.bz2, .tar.xz, .tar.lz4, .tar.sz,
extract.rar

see
[https://news.ycombinator.com/item?id=18486253](https://news.ycombinator.com/item?id=18486253)

------
fergie
I’m surprised that nobody is mentioning plain old Bash. The builtins are
pretty powerful, and in many ways Bash is the “standard” cli.

------
rajadigopula
Git Standup - [https://github.com/kamranahmedse/git-
standup](https://github.com/kamranahmedse/git-standup)

Coinmon (Requires node) -
[https://github.com/bichenkk/coinmon](https://github.com/bichenkk/coinmon)

------
dharmab
httpie + jq is a great duo for exploring and manually probing APIs.

Gron (grep JSON) is handy when you get a massive API response and quickly need
to figure out what subkeys interest you.

The silver searcher (ag) is my go-to code search tool. I'll have to try
ripgrep to compare.

Pass is neat for injecting personal secrets into bash scripts securely.

~~~
petdance
Here's a feature comparison chart of the various grepalike tools:

[https://beyondgrep.com/feature-comparison/](https://beyondgrep.com/feature-
comparison/)

------
jpeeler
I really appreciate the people who include descriptions and links for their
list. My list has been pruned to avoid duplication (though perhaps knowing
what's popular is a good metric too).

asdf: [https://github.com/asdf-vm/asdf](https://github.com/asdf-vm/asdf) \-
installs many different programming languages and supports installing
different versions concurrently. I use it for go installs since distribution
updates aren't usually fast enough.

solaar: [https://github.com/pwr/Solaar](https://github.com/pwr/Solaar) \-
handles configuring a logitech unifying receiver in Linux. Not really
something you'd use multiple times, but am thankful it exists (also has a GUI
too I believe).

------
maxxxxx
I am always impressed by the usefulness of the git command line. If you wanted
to write a GUI for it you usually would have a library to link to but the GUIs
(e.g SourceTree) I have seen use the command line and still get good
performance.

Another one is ffmpeg. A ton of tools are built on it.

For photographers exiftool is great.

------
hddherman
byobu ([http://byobu.co/](http://byobu.co/)) is an amazing thing to have on
your remote server, sessions and switchable windows + splits make this a must-
have tool. Think of it as tabs but for your SSH session, plus many more
features.

~~~
sfdgsdfg
People might be more familiar if you would describe it as a t-mux alternative.

~~~
nrclark
Just a quick note on this - byobu isn't a tmux alternative exactly. It
actually uses tmux (or screen) on the back-end. So it's more like a nicely
configured tmux.conf/.screenrc with standardized bindings.

------
gh02t
Some of my favorites, apart from the obvious ones like Vim/Emacs and common
Unix utils...

    
    
        notmuch - email database 
        ncmpcpp - MPD frontend (music player)
        taskwarrior - task and time management
        mutt - email
        ranger - file manager
        pass - password manager

------
bovermyer
Besides what others have added, I also love:

proselint: [http://proselint.com/](http://proselint.com/)

alex: [https://github.com/get-alex/alex](https://github.com/get-alex/alex)

Both are CLI linters for prose.

------
honkycat
Steam locomotive sl is ESSENTIAL to any command line work. If you don't use it
you are a fool.

------
spurgu
Lots of great stuff here! Key takeaway though (for me at least) is that a lot
of this stuff turns into cumbersome management if you're not doing the bulk of
your work on localhost, but instead dealing with a various few dozen or
hundreds (in my case) of different servers. Yeah you can use ansible to
automate installation/setup, but then again if you suddenly end up on a fresh
server without root access you're gonna be/feel crippled, being used to
aliasing everything and replacing standard shells with something extra fancy.

Some level of balance is needed, which is what I've been trying to do. That
said I always setup oh-my-zsh and `git config --global alias.kurwa status`
wherever I go.

~~~
em-bee
localhost or remote does not make a difference, any manual setup required is
annoying either way.

most of the tools don't need manual configuration though and so it's a single
command to install all of them that you can have tucked away somewhere to use
when needed.

but yeah, i use salt for automating this.

------
cntlzw
z - jump around [https://github.com/rupa/z](https://github.com/rupa/z)

------
rawoke083600
Guake - dropdown terminal with tabs for linux :) I can't see my day without it
!

~~~
em-bee
that's not a CLI tool but a tool for running CLI commands :-)

~~~
rawoke083600
Hahah true ! But damn its useful!

------
yesenadam
Maybe the best part of bash for me is AWK - so useful, and enjoyable to use. I
use ffmpeg a lot for making movies from images, video conversion etc. I use
Sage on the command line, mostly for programming in Cython and mathematical
stuff with the Sage/Python REPL. It was 2.7GB (!) and comes with an absurd
number of libraries and packages[0], mostly for maths and graphics. I started
by using it in a browser notebook, but switched to the command line and never
went back.

[0] [http://www.sagemath.org/links-
components.html](http://www.sagemath.org/links-components.html)

------
zzo38computer
I agree. A lot of them come with a UNIX system, although there are others. I
use some of the moreutils stuff. For email, I use Heirloom-mailx. For text
editing, I use vim. For database I use SQLite. For typesetting I use TeX. For
processing pictures I implemented my own package called Farbfeld Utilities.
For making MOD/XM musics, I wrote AmigaMML which uses a text file rather than
the GUI that many other programs do. Hopefully other people on here can
mention even more, because I am interested in the answer too, and probably my
answer is insufficient to the original asker anyways.

------
app4soft
1) _Moon Buggy_ \-- ASCII art version of moon-buggy game.[0]

2) _SHPaint_ \-- ANSI Art editor programmed in bash.[1,2]

[0] [http://www.seehuhn.de/pages/moon-
buggy.html](http://www.seehuhn.de/pages/moon-buggy.html)

[1] [http://bruxy.regnet.cz/web/linux/EN/ansi-art-sh-
paint](http://bruxy.regnet.cz/web/linux/EN/ansi-art-sh-paint)

[2]
[https://www.youtube.com/watch?v=aoAMxMukgPY](https://www.youtube.com/watch?v=aoAMxMukgPY)

------
em-bee
a tool that looks very promising is xiki: [http://xiki.org/](http://xiki.org/)
i haven't been able to try it myself yet, but i am curious to hear if anyone
else has played with it.

sadly the creator hasn't been able to work on it since the last funding
campaign failed, but he is preparing a new campaign just now:
[https://groups.google.com/forum/#!topic/xiki/Dvzo14Lhoyg](https://groups.google.com/forum/#!topic/xiki/Dvzo14Lhoyg)

greetings, eMBee.

------
rplnt
> I really enjoy using a command-line interface instead of a graphical user
> interface

I'm not sure what kind of interface you mean here, but judging by the
responses graphical interface in terminal is OK. In that case,

*lazygit [https://github.com/jesseduffield/lazygit](https://github.com/jesseduffield/lazygit)

first GUI on top of git that I didn't hate. Primarily because it doesn't break
the flow in command line. Instead of diff/add/commit I open this, but for the
rest I still use git directly (or through aliases).

------
vram22
I wouldn't call it among the best, but it has a real-life use, and was, and
maybe still is, used in production by a large motorcycle manufacturer, for
whom I originally wrote it:

[https://jugad2.blogspot.com/2014/09/my-ibm-developerworks-
ar...](https://jugad2.blogspot.com/2014/09/my-ibm-developerworks-article.html)

I had given some more details about it on HN some time ago:

[https://news.ycombinator.com/item?id=17327807](https://news.ycombinator.com/item?id=17327807)

------
non-nil
BorgBackup:
[https://github.com/borgbackup/borg](https://github.com/borgbackup/borg)

Deduplication, compression, encryption, to local or remote targets.

~~~
h1d
restic and duplicacy are modern alternatives.

~~~
explainplease
They are, but Borg is also modern.

------
locusofself
I love 'bpython' , python CLI with syntax highlighting and autocomplete for
testing out quick ideas.

Slightly off topic, but can I just say that iTerm2's native tmux integration
is really awesome.

~~~
spondyl
Ah yes! I knew I had forgotten to install something recently

------
kuroguro
I wonder if there's any 2FA code storing/generating cli application? I know
they aren't supposed to be used like that but storing them all on just a phone
doesn't seem wise in the long run. Might be useful while building some
automated scripts as well.

_edit_

oathtool seems promising (needs to be paired with something to manage and
crypt the keys tho) [http://www.nongnu.org/oath-
toolkit/oathtool.1.html](http://www.nongnu.org/oath-toolkit/oathtool.1.html)

~~~
erinnh
I use totp-cli:

[https://github.com/WhyNotHugo/totp-cli](https://github.com/WhyNotHugo/totp-
cli)

------
znpy
I am getting fonder and fonder of xargs. It basically reads some input and
appends it to a pre-supplied string. Then executes the newly created string as
a command.

Trivial example:

    
    
        ls -1 | xargs -L1 echo processing 
    
    

I am finding it quite useful to load and delete a bunch of netapp volume
snapshots in a single line:

    
    
        ssh netappuser@netapphost volume snapshot show $volname | awk '/selector_pattern/{print $1}' | xargs -L1 ssh netappuser@netapphost volume snapshot delete $volname

~~~
aptmiguk
With xargs (and find), I wish I would've found this sooner:

find test -print0 | xargs -0 file

"This allows file names that contain newlines or other types of white space to
be correctly interpreted by programs that process the find output. This option
corresponds to the -0 option of xargs."

~~~
tyingq
Perl also supports -0 and is handy for some use cases because it won't spawn a
process per line like xargs.

    
    
      # remove files without spawning lots of rm processes
      find . -name "*.xyz" -print0 -type f| perl -0 -ne 'chomp;print "$_\n";unlink;'

------
Already__Taken
As a windows admin, docker has actually been super handy for running CLI tools
with platforms (linux) that I can't easily get or have no will to compile
natively myself on windows.

------
geowwy
fzf is awesome. I use it in vim and bash.

[https://www.tecmint.com/fzf-fuzzy-file-search-from-linux-
ter...](https://www.tecmint.com/fzf-fuzzy-file-search-from-linux-terminal/)

\----

I use the Silver Searcher all the time. Very fast.

[https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)

\----

tig, a text mode interface for git.

[https://github.com/jonas/tig](https://github.com/jonas/tig)

~~~
CJKerr
It's been mentioned previous, but you should check out ripgrep - it's even
faster than Silver Searcher a lot of the time

[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

~~~
bjoli
Does anyone not working on million-line codebase ever find themselves limited
by grep? I am genuinely curious.

~~~
CJKerr
Unfortunately, I work on a million-line codebase.

Grep might be fine 99% of the time, but there's no reason to not drop a
ripgrep binary on every machine I use regularly.

Ripgrep is faster across the board and has better defaults for working in Git
repositories. Since I'm working with a large codebase managed in Git, it's a
no-brainer.

------
msmart
Haven't seen Hledger [[http://hledger.org/](http://hledger.org/)] in the
recommendations. It is a great accounting tool!

------
ryannevius
Sort of on topic...Does anyone know of a good interactive resource for
learning some of the tools that are included by default on UNIX systems? RTFM
is useful, of course.

~~~
yesenadam
Not sure what you mean interactive - trying things out on bash itself is a
good way to learn. I put together a (quite long) single-webpage _not-so-quick
guide to bash shell_ ,[0] which covers a lot of the basic stuff (well, with
separate pages for grep/sed and AWK), at the bottom of the page are links to
the best bash websites and names of the best books that I've found. Hope
that's of some use. But yeah, the man pages become perfectly adequate
guides/refreshers once you've learnt the basics of a command/tool - especially
using them with "/" for searching for what you want.

[0] [http://www.adamponting.com/mac-terminal/](http://www.adamponting.com/mac-
terminal/)

------
ronancremin
I can't believe nobody has mentioned VisiData. It's like Vim, but for
structured data.

[https://VisiData.org](https://VisiData.org)

------
petdance
Various grepalike tools like ack, ag and rg have been mentioned. Most comments
seem to be based on which tool runs simple searches faster, but note that
their feature sets vary widely.

Here's a handy chart that compares the features of each of these tools, along
with git grep and plain ol' GNU grep.

[https://beyondgrep.com/feature-comparison/](https://beyondgrep.com/feature-
comparison/)

------
jolmg
I guess these are so obvious no one mentioned them, but: ssh, git, zsh, bash,
curl, wget, gpg, gzip, xz, btrfs, qemu, pv, tar, diff, comm, column, sort,
uniq, sed, bc, tr, od, xxd, tcpdump, tshark, ping, nmap, ip, iw, xdotool,
xrdb, grep, pgrep, pkill, lsof, inotifywait, journalctl, systemctl, convert,
ed, and probably countless more I'm taking too much for granted to remember.

------
sndean
My top 4:

    
    
         40.2%  ls
         22.8%  cd
         15.6%  python
         3.6%   nano
    

Since no one's mentioned it yet: I don't necessarily think nano is great, but
it's always there and it opens immediately. Almost all small, quick edits I
make (where opening VSCode/Emacs/whatever doesn't make sense) are done in
nano. Pretty useful.

~~~
Lordarminius
Nano simply and efficiently gets the job done in 70% of cases.

Nano Vim Xdg youtube-dl wttr git curl top watch

------
ComputerGuru
* fish - essential prerequisite in order to live in the command line

* autojump (aka j) - for changing directories quickly

* open - required to interact with the non-cli world, ships by default on macOS and here's one for Windows/WSL: [https://github.com/neosmart/open](https://github.com/neosmart/open)

* imgpaste - for pasting screenshots into a PNG or JPEG directly ([https://github.com/neosmart/imgpaste](https://github.com/neosmart/imgpaste))

* pbpaste - for pasting into the shell (or if you're on Linux or Windows: [https://github.com/mqudsi/fish-config/blob/master/functions/...](https://github.com/mqudsi/fish-config/blob/master/functions/pbpaste.fish))

* fzf - a general-purpose "selector" ui for choosing "things" from a list based off, such as your history (bound to ctrl+r) or files in a directory (bound to ctrl+p with input generated by bfs or fd)

* neovim - my configuration here: [https://github.com/mqudsi/nvim-config](https://github.com/mqudsi/nvim-config)

* ripgrep - for finding strings in files

* fd - for finding files quickly

* sed (with -r) - insanely powerful for common string operations

* tr - lets you deal with line endings, which sed can't

* youtube-dl - download youtube videos from the CLI

* curl/httpie - (scriptable) network requests

* aria2c - high-speed (multi-threaded) downloads and torrent downloads, it just works

* jq - for manipulating json in shell scripts

* ncdu - find space taken up by directories/files, but it's aging and in need of a dire rewrite like fd/rg did for find/grep

* pbedit - edit the contents of the clipboard in your favorite editor [https://github.com/mqudsi/fish-config/blob/master/functions/...](https://github.com/mqudsi/fish-config/blob/master/functions/pbpaste.fish)

* weechat - irc in your command line

* ffmpeg - except I am much more likely to use it via one of the wrapper fish scripts I've written such as ffencode, fftrim, ffconcat, ffmute, etc. because it is (necessarily) so damn verbose and infinitely tunable.

* tmux - if I'm working remotely or on a headless machine where I can't just ctrl+shift+n to open a new terminal window (which I prefer)

~~~
michaelmior
> tr - lets you deal with line endings, which sed can't

I'm not sure what you mean by "deal with line endings", but sed can operate
across multiple lines.

[https://www.gnu.org/software/sed/manual/html_node/Text-
searc...](https://www.gnu.org/software/sed/manual/html_node/Text-search-
across-multiple-lines.html)

~~~
ComputerGuru
I mean directly operating on the line ending itself. e.g. remove all lines or
replace `\n` with the record separator, etc.

~~~
jfhufl
Like so?

    
    
        % echo 'one\ntwo\nthree' | sed -e 's,$, four,'
        one four
        two four
        three four

~~~
ComputerGuru
No, like this:

    
    
        > echo ‘one\ntwo\nthree’ | tr \n \|
        one|two|three

~~~
Tepix
echo -e 'one\ntwo\nthree' | sed -ze 's/\n/|/g'

~~~
ComputerGuru
Hey, thanks for teaching me that!

------
SamWhited
I use mcabber and irssi for chat. Mcabber doesn't really support much in the
way of features (so even on a modern XMPP server you're missing simple things
like fetching history), but its vi style shortcuts and nice layout mean I
can't give it up. Combined with jmp.chat I can even send text messages from
it.

------
tyingq
Some I like...

jq - process json on the command line:
[https://stedolan.github.io/jq/](https://stedolan.github.io/jq/)

perl one liner to debug a regex: perl -e 'use re "debug"; "xyz" =~ /x*y+z/;'

"hd -c" \- I like this hexdump format

lsof - debug open files/sockets/etc

------
sirwitti
Vue-cli is pretty awesome! [https://cli.vuejs.org](https://cli.vuejs.org)

~~~
rutierut
I really really don't like what they did with version 3. What the heck is
happening in my app? And what coder whants a gui for his dependencies???

------
moshohayeb
I can't believe no one mentioned parallel[1] yet, it is basically a _much_
more powerful replacement to xargs and available at most package managers.

[1]
[https://www.gnu.org/software/parallel/](https://www.gnu.org/software/parallel/)

------
pmoriarty
Here's my list of 369 useful programs:

[https://paste.pound-
python.org/raw/Uqc8XTFk73Y3PpbRe9hC/](https://paste.pound-
python.org/raw/Uqc8XTFk73Y3PpbRe9hC/)

It's not 100% made up of command-line programs, but most of them are.

------
zwilson
fzf - command-line fuzzy finder
[https://github.com/junegunn/fzf](https://github.com/junegunn/fzf)

Easy to overlook... I almost don't even notice it, but I use it more than any
other application (every time I type).

------
kh_hk
peerflix -
[https://www.npmjs.com/package/peerflix](https://www.npmjs.com/package/peerflix)

A streaming torrent client. I guess there are similar ones.

Watching a torrent becomes:

    
    
        peerflix <magnet> --mplayer -t subtitle

------
leeman2016
neofetch
[[https://github.com/dylanaraps/neofetch](https://github.com/dylanaraps/neofetch)]
for showing a friendly system information

gst123
[[http://space.twc.de/~stefan/gst123.php](http://space.twc.de/~stefan/gst123.php)]
a music player

prettyping
[[https://github.com/denilsonsa/prettyping](https://github.com/denilsonsa/prettyping)]
a prettier ping

kakoune [[https://github.com/mawww/kakoune](https://github.com/mawww/kakoune)]
a nice (relatively friendly) modal text editor

------
luislezcair
I use `ack` ([https://beyondgrep.com/](https://beyondgrep.com/)) as a
replacement for `grep`. It is simpler, faster, it has colors by default and
it's really fast and very useful for programming.

~~~
michilehr
Very useful - I use ack-grep for MacOS

------
em-bee
supmua. [https://github.com/sup-heliotrope/sup](https://github.com/sup-
heliotrope/sup) beats mutt hands down. groups emails by tags instead of
folders.

and it allows to open multiple views at once, keeping state in each. it also
supports saved searches as a view.

it's not actively maintained right now, but it is stable. i haven't had any
problems yet.

sup is the ancestor of the notmuch libraries which can be integrated into
mutt. but i don't know how well that works. perhaps
[https://news.ycombinator.com/item?id=18483833](https://news.ycombinator.com/item?id=18483833)
can shed some light on that.

greetings, eMBee.

~~~
em-bee
quoting [https://notmuchmail.org/notmuch-
mutt/](https://notmuchmail.org/notmuch-mutt/)

> notmuch-mutt, which will create a "virtual" maildir folder with search
> results whenever a search is made. The upside is that you can search all
> your folders simultaneously; the downside is that your modifications in the
> results listing do not carry over, also having to switch folders comes with
> some more annoyances.

sup does not have that problem. i have used mutt for more than a decade.
switching to sup was a revelation. i would really love to see any alternatives
that can compete with it.

greetings, eMBee.

------
Artemix
I almost constantly listen to music. When I do so, I only use cmus nowadays.

Awesome lightweight music player

------
EamonnMR
imagemagick - Clint too for changing images. When you need to turn an entire
folder of pictures into a single PDF, encode them so that the file size isn't
huge and scale them to avoid morie patterns, it's the tool of choice.

------
gooseyard
Everything else I like has been mentioned, save for GNU datamash
([https://www.gnu.org/software/datamash/](https://www.gnu.org/software/datamash/))

------
expertentipp
I would gladly see a list of useful aliases for omnipresent CLI utilities like
`grep`, `ls`, `cat`, `less`, `cut`, etc. They're surprisingly powerful but
going through their man pages is like reading a whole library.

~~~
philbarr
tldr is really handy for that: [https://github.com/tldr-
pages/tldr](https://github.com/tldr-pages/tldr)

------
hrbf
Check out: [https://github.com/herrbischoff/awesome-command-line-
apps](https://github.com/herrbischoff/awesome-command-line-apps)

You’ll be sure to find something useful.

------
nodesocket
For sysadmin needs:

    
    
      - htop (better top)
      - nload (network traffic visualization)
      - nano (I know, but works great for simple editing)
      - curl (http everything tool)
      - telnet/nc (check listening ports)

~~~
roboyoshi
I hate that nano is so looked down on. I use it too and it's a great tool. I
don't feel any shame using it.

------
chrisweekly
lnav - mini-ETL w/ embedded sqlite; parse and query logfiles or any other
structured text-based input... it's powerful, intuitive, extensible.

[https://lnav.org](https://lnav.org)

------
plibither8
Here's a simple game - 2048 in your terminal :) :
[https://github.com/plibither8/2048.cpp](https://github.com/plibither8/2048.cpp)

------
nazri1
(shameless plug) git number: [https://github.com/holygeek/git-
number](https://github.com/holygeek/git-number)

Use numbers for dealing with files in git.

------
0xphk
multitail, a powerful tail replacement with highlighting, split panes and
comfortable buffer search. mostly used in long running tmux sessions.

for example, u could pipe in tcpdump output to analyze dump in realtime

------
veddox
My setup on servers and programming environments:

    
    
      * fish shell
      * tmux (multiplexer)
      * emacs-nox (non-GUI version)
      * mocp (music player)
      * w3m (web browser)
      * htop (process viewer)

------
efreak
for a software keyboard, since I've seen several lists of aliases:

```alias ,v='mv' alias r,='mv'```

Otherwise:

ttyclock tmux/byobu pv ncdu htop megadl webcomix and/or dosage - download
webcomics into cbz files for local viewing. Installable via pip. elinks,
links2 - Browsers. especially useful if compiled with javascript support. nnn
aria2c grc most mlocate (prrovides thelocate and updatedb connands. I can't
recall why i like it more than slocate or find-utils)

Generally built-in:

watch tee sed (or just use `perl -pi -e` 7z

'Fun' cli programs:

nyancat sl cowsay toilet ttysolitaire

------
tbrock
Saw: [https://github.com/TylerBrock/saw](https://github.com/TylerBrock/saw)
\-- Stream (tail -f) colorized AWS CloudWatch logs

------
yoz-y
subliminal:
[https://github.com/Diaoul/subliminal](https://github.com/Diaoul/subliminal)

great tool for downloading subtitles, sadly it seems unmaintained and
sometimes fails to work

rtorrent:
[https://github.com/rakshasa/rtorrent](https://github.com/rakshasa/rtorrent)

my preferred way to download ISOs of Linux distributions

And a +1 for some that were already mentioned: tig, ripgrep, htop, midnight
commander

------
cyberpip
[https://github.com/mfaerevaag/wd](https://github.com/mfaerevaag/wd) \- Jump
to custom directories in zsh

------
feross
WebTorrent [https://github.com/webtorrent/webtorrent-
cli](https://github.com/webtorrent/webtorrent-cli)

------
hi41
I love ImageMagick. We were able to write a script to join thousands of images
from command line. The manual GUI way of joining images would have been
incredibly slow.

------
purplezooey
How about Ly, the terminal display manager:
[https://github.com/cylgom/ly](https://github.com/cylgom/ly)

F yeah, dude.

------
hjek
One that I use a lot and I haven't seen mentioned here is `dict` which is fine
for looking up word definitions and acronyms if a bit limited for
translations.

------
devonkim
AWS CLI replacement: awless
[https://github.com/wallix/awless](https://github.com/wallix/awless)

------
nanna
\- pdfgrep : grep search pdfs

\- htop : A nicer version of the process viewer top

\- rename : bulk rename things via a regex/sed-like interface

\- youtube-dl -x : download the audio of a video

\- locate : Find something anywhere.

~~~
amelius
> locate : Find something anywhere.

I strongly dislike updatedb, which is always stealing CPU cycles at
inconvenient moments, and locate often seems out of date.

We should have had instant, database-like indexing in our filesystems ages
ago.

~~~
_arvin
You can run updatedb more frequently. By default it is run on a daily cron job
and has the smarts to not run when on battery. (see /etc/cron.daily/mlocate)

You can also exclude directories in /etc/updatedb.conf that you don't want
locate to index. I think in your case a more frequent cron job make sense. If
run often enough, it finishes very quickly when running updatedb, which will
you give you the instant search you're looking for.

------
andersonvom
gitsh -
[https://github.com/thoughtbot/gitsh](https://github.com/thoughtbot/gitsh)

Since git is by far the command a lot of people type the most, this shell
comes in really handy. It supports all regular git aliases, has
autocompletion, super useful for setting temporary names when pair
programming, and you can set default commands to be run when you just press
return.

------
SuddsMcDuff
sox - the Swiss Army knife of sound processing programs

[http://sox.sourceforge.net/](http://sox.sourceforge.net/)

------
BasicObject
remind:
[https://dianne.skoll.ca/projects/remind/](https://dianne.skoll.ca/projects/remind/)

alpine: [https://repo.or.cz/alpine.git](https://repo.or.cz/alpine.git)

mg: [https://github.com/hboetes/mg/](https://github.com/hboetes/mg/)

------
RomanZolotarev
tmux: [https://man.openbsd.org/tmux](https://man.openbsd.org/tmux)

vi: [https://man.openbsd.org/vi](https://man.openbsd.org/vi)

entr: [http://entrproject.org/](http://entrproject.org/)

shellcheck: [http://shellcheck.net](http://shellcheck.net)

------
krylon
I really like the find(1) command on Unixoid systems. On Windows, I have
installed git some machines simply to have grep and find available.

------
hypertexthero
Hugo static website generator - [https://gohugo.io/](https://gohugo.io/)

------
em-bee
a very useful set of utilities, that i only recently discovered here on
hackernews are imv and qmv from
[http://www.nongnu.org/renameutils/](http://www.nongnu.org/renameutils/)

it makes renaming of long filenames much easier. especially if there are many
files with similar names.

greetings, eMBee.

------
phxql
Taskwarrior: [https://taskwarrior.org/](https://taskwarrior.org/)

------
dtjohnnymonkey
Insect for converting between units

[https://insect.sh](https://insect.sh)

------
yboris
diff2html: [https://diff2html.xyz/](https://diff2html.xyz/) \-- view your diff
color-coded in HTML

just run `npm install -g diff2html-cli` and `diff2html`

I recommend this alias `alias diff='diff2html -s side'`

------
whyleyc
One line bash command to convert (almost) any type of file to any another
format using the Zamzar API.

Convert PDF to Word, Powerpoint to JPG, WMV to MP4, DWG to PDF etc:

[https://github.com/zamzar/zamzar-bash](https://github.com/zamzar/zamzar-bash)

(Full disclosure: I'm one of the co-founders at Zamzar).

------
Annatar
AWK: lighweight, fast, versatile, incredibly powerful programming language.

------
0xf8
one of my favorites is Sym. " Symmetric Encryption that's easy on Humans"

[https://github.com/kigster/sym](https://github.com/kigster/sym)

------
pacifika
Ncdu

------
h1d
pwgen - Handy to create a password. It generates dozens at once which you can
pick from.

cal - Obvious but I still launch GUI calendar app when I can just type 3
letters to check on dates.

------
breck
* tldr - better than man in 80% of cases

* htop - better version of top for multi-core machines

* tmux - when you want to run long-running commands

------
sys_64738
Emacs. Because it is.

------
tonysdg
`sl` -- makes you feel better about mis-typing `ls`!

------
biql
fasd - fast navigation in command line

asdf - universal installation tool for ruby, node, go, etc

ripgrep - very fast search

zsh - shell (with zsh-autosuggestions and fasd hooks)

~~~
qorrect
I'll second fasd , for me though bash with bash-it is easier than setting up
zsh.

~~~
biql
I found zsh to be quite easy to setup with oh-my-zsh. The installation is a
few commands and the defaults are sane, I use it with minimum modifications.
YMMV

------
dllthomas
I'm not big on applications, period. Activities should be decomposed (or at
least decomposable) into individual actions that I can stitch together in the
shell.

~~~
chrisseaton
Aren’t those individual actions still applications? I don’t know what you
mean?

~~~
dllthomas
There's a frequent (but by no means universal) distinction drawn between
"applications" and "utilities". In the former case, you have repeated
interaction with a single process, typically with some measure of "ownership"
of its display port. On the other hand, a utility typically does a single
thing, produces some output, and then exits.

------
PJ_Maybe
dtrx - Do The Right Extraction. It's a tool "for Unix-like systems that takes
all the hassle out of extracting archives":
[https://brettcsmith.org/2007/dtrx/](https://brettcsmith.org/2007/dtrx/)

In Debian/Ubuntu you can install via apt.

Also, I'd second tldr which has been mentioned here already. It provides
simplified man pages which common usage examples that normally fit on a few
lines on screen: [https://tldr.sh/](https://tldr.sh/)

~~~
CJefferson
Dtrx is awesome, but is unfortunately slowly dying, as the author seems to
have abandoned it -- it can't be installed with pip anymore.

I think I'm going to take it over, just need a name...

~~~
Cyphase
Kdtrx: Keep Doing The Right Extraction

------
drpossum
units

Doing any kind of engineering or science, this is my go to calculator for
stuff that I find a lot of people using google for

------
flavor8
todo.txt - todo list manager with extensions (e.g. git sync, google tasks
integration, etc).

------
heuiop
iftop - top for network interfaces.

vnstat - the simplest traffic stat collector I could find.

------
chapium
grep is one of the most useful tools that you can use on the commandline

------
enriquto
the elinks browser blew my world a few years ago

------
aprdm
vim and tmux!

------
blibble
moc for a music player

calcurse for calendar

mutt for email client

------
modernerd
tldr - community-maintained man pages distilled to snippets

[https://tldr.sh/](https://tldr.sh/)

------
cpburns2009
I frequently use:

\- git

\- grep

\- head

\- man

\- rsync

\- screen

\- sshfs

\- tail

\- watch

\- vim

I recently discovered:

\- colordiff

\- paste

------
kinard
XTree Gold

------
twic
sed

------
mdekkers
Midnight Commander (mc);

nano;

htop;

dstat;

git;

tmux;

------
densone
pine

------
sgt
psql

------
modzu
pipe

------
laixintao
jq

It saved my life.

------
popee
netcat

~~~
nurettin
the one that comes with nmap?

~~~
popee
Doesn't matter because every re-implementation of that old unix tool is made
for same purpose and mostly accept same arguments.

For example you can make tar archive and pipe it to nc. On other server nc
would accept data and pipe it to tar for unpack. This shows real power of unix
pipes.

~~~
nurettin
I asked, because the one from nmap actually supports multiplexing.

------
em-bee
here is a list of all tools mentioned in the thread. unfortunately, including
descriptions and links made the comment to large, so for now just the names.
the number in front is the number of mentions.

links to other lists:

[https://beyondgrep.com/feature-comparison/](https://beyondgrep.com/feature-
comparison/)

[https://code.kiwi.com/lesser-known-tools-we-love-at-kiwi-
com...](https://code.kiwi.com/lesser-known-tools-we-love-at-kiwi-com-
part-1-of-3-cli-79eb6d67a065)

[https://github.com/agarrharr/awesome-cli-apps#terminal-
utili...](https://github.com/agarrharr/awesome-cli-apps#terminal-utilities)

[https://github.com/alebcay/awesome-
shell#applications](https://github.com/alebcay/awesome-shell#applications)

[https://paste.pound-
python.org/raw/Uqc8XTFk73Y3PpbRe9hC/](https://paste.pound-
python.org/raw/Uqc8XTFk73Y3PpbRe9hC/)

[http://suckless.org/rocks/](http://suckless.org/rocks/)

[https://www.networkworld.com/article/3091139/linux/who-
needs...](https://www.networkworld.com/article/3091139/linux/who-needs-a-gui-
how-to-live-in-a-linux-terminal.html)

    
    
           2048
           2fa
           abcde
           abook
       [3] ack (ack-grep)
       [5] ag (silver searcher)
           alex
       [2] alpine
       [2] amigamml
           aplay
           archiver
       [4] aria2c
           asciinema
       [2] asdf
           atom
       [2] autojump (aka j)
           autossh
           autosub
       [3] awk
           awless
       [2] bash
           bash-it
           bass
       [5] bat (cat)
           bcal
       [3] bc -l
       [2] beets
           bitlbee
       [3] BorgBackup
       [2] bpython
       [2] brew
           btrfs
           buku
       [2] byobu
           calcurse
           cal
           cat
       [2] cd
           Chocolatey
       [2] climate (shell utility tools)
       [3] cmus
           Coinmon
           colordiff
           column
           comm
           convert
       [2] cowsay
           cp
       [4] curl
           GNU datamash
           ddgr
           ddrescue
           dict
           diff
           diff2html
           direnv
           diskus
           docker
       [2] Doom Emacs
           dosage
           dstat
       [2] dtrx
       [2] duplicacy
           ed
       [2] elinks
       [7] emacs
       [2] entr
       [2] exa
       [2] exiftool
           fab
           Farbfeld Utilities
       [3] fasd
       [5] fd
       [5] ffmpeg
           finch
       [2] find
           findutils
       [8] fish-shell
           frp
           fselect
       [6] fzf
           gawk
      [13] git
           git-annex
           git-annex assistant
           git-bulk-toolkit
           git number
       [3] gitsh
           Git Standup
           glances (top)
           Goaccess
           go-jira
           tuijam
       [2] googler
           gpg
           graphicsmagick
       [2] grc
       [5] grep
           Gron
           gst123
           gzip
           hangups (instant messaging)
           hd -c
           head
           heirloom-mailx
           hledger
           hollywood (tmux UI)
           howdoi
           hr
      [11] htop
       [4] httpie
           hub
           Hugo
           hyperfine
           iftop
       [2] ImageMagick
           imgpaste
           imgp
           import-mailbox-to-gmail
           inotifywait
           Insect (unit converter)
           ip
           irssi + jmp.chat
           iw
           journalctl
       [7] jq
           kakoune
           keysniffer
           keychain
           khal
           khard
           Kubectx
       [2] lazygit
           ledger-cli
           links2
           lnav
           localhost.run
           locate
       [3] ls
       [2] lsof
           lumail
           Ly
           man
           mcabber
           mediainfo
       [2] megadl
           mg
       [4] midnight commander
           Miller (CSV tool)
           mkdir
           mlocate
       [2] mocp
           Moon Buggy (game)
           moreutils
       [3] mosh
       [2] most
           mountsshfs
           mpv
           multitail
       [5] mutt
           mv
       [3] mycli
       [6] nano
       [3] nc
           ncat
       [7] ncdu
           ncmpcpp
           neofetch
           neomutt + notmuch
       [2] neovim
           netcat
           nethogs
           newsboat
       [4] Ngrok
           nload
           nmap
       [3] nnn
           notmuch
           nyancat
           od
           ohmyfish
       [4] ohmyzsh
           oh-my-zsh git plugin
       [2] open
           p7zip
       [2] Pandoc
           GNU parallel
       [5] pass
           passgo
           pass-otp
           paste
           pbedit
           pbpaste
           pdd
           pdfgrep
           peco
           peerflix
       [3] perl
       [3] pgcli
           pgrep
           pianobar
           pine
           ping
           pip
           pipe
           pkill
           playmod
           prettyping
           prezto
           progress
           proselint
           psql
       [2] ptpython/ptipython
       [4] pv
       [2] pwgen
           pytest
       [2] python
           pythonPackages.powerline
           qemu
       [4] ranger
           rclone
           recoll
       [2] remind
       [2] rename
           renameutils
       [2] restic
      [13] rg (ripgrep)
           rm
       [4] rsync
           rtorrent
           rtv
           sage
           Saw (AWS Cloudwatch)
           sc-im
           sclack
           SCM Breeze
       [2] Scoop
       [4] screen
       [4] sed
           serve
           serveo
       [3] shellcheck
           SHPaint
           shuf
       [3] sl
       [4] socat
           solaar
           sort
           sox
       [2] sqlite shell
       [2] ssh
       [3] sshfs
           subliminal
           supmua
           surfraw
           sym
           systemctl
           tabview
           tail
       [2] tar
       [3] Taskwarrior
           tcpdump
           tee
           TeX
       [2] The Fuck
       [6] tig
       [4] tldr
           tmate
      [21] tmux
           todo.txt
           toilet
           top
           totp-cli
           touch
       [2] tr
       [2] tree
           tshark
           ts
           ttp
           ttyclock
           ttysolitaire
           rainbowstream
           unimatrix
           uniq
       [2] units
           up
           vdirsyncer
       [2] vi
           vifm
       [7] vim
       [4] Visidata
           vnstat
           Vue-cli
       [2] w3m
       [6] watch
           watch (python)
           watchman
           wd
           webcomix
       [2] websocketd
           WebTorrent
       [3] weechat
       [2] wee-slack
       [2] wget
           wordgrinder
           wttr
       [2] xargs
           Xdg
           xdotool
           xiki
           xmlstarlet
           xrdb
       [2] xsv
           XTree Gold
           xxd
           xz
       [6] Youtube-dl
           youtube-viewer
       [2] z
           zamzar-bash
           zgen
           zplug
       [4] zsh

~~~
em-bee
i just discovered some awesome tools in the _moreutils_ package mentioned
elsewhere in this discussion:

 _sponge_ : soaks up stdin, so you can pipe it back to the same file you just
read. compare:

    
    
      grep -v "^me:" /etc/passwd > /etc/passwd # failed attempt to remove user *me*.
      grep -v "^me:" /etc/passwd | sponge /etc/passwd # this works because sponge will wait until the grep is completed before writing back to the file.
    

another is:

 _vipe_ : insert vi into a pipe to do some manual editing of the data while
it's handled in a pipe. could also be useful to preview pipe contents while
they are being processed.

moreutils also includes _vidir_ , an alternative to _qmv_.

greetings, eMBee.

