
Fish shell - Aloha
http://fishshell.com/
======
ridiculous_fish
Hey, I'm the lead dev of the fish shell. There's some great discussion in this
thread!

For those who are interested, the fish shell is about to release version 2.2,
a very significant release that wraps up eighteen months of development. You
can try the beta now: [http://fishshell.com/beta/](http://fishshell.com/beta/)

A sampling of new features:

\- vi mode (yay!)

\- Abbreviations, fish's take on aliases. They expand as you type them.

\- A new "inline" pager, inspired by zsh. It's searchable and supports
progressive disclosure. See it in action:
[https://www.youtube.com/watch?v=ncVWbT-
jWAw](https://www.youtube.com/watch?v=ncVWbT-jWAw)

\- A redesigned theme and prompt chooser:
[http://fishshell.com/beta/assets/img/screenshots/web_config....](http://fishshell.com/beta/assets/img/screenshots/web_config.png)

\- Tons of new tab completions!

~~~
PSeitz
Hi, can you tell how it competes to cmder and iterm? I use these currently in
windows and osx

~~~
sspiff
Not sure about this (I haven't used either, just looked at their sites), but I
believe those are terminal emulators. They're the thing that displays the
shell and handle input and copy/paste etc.

The shell is what actually handles key presses and produces the output
(handling commands, input/output redirection, etc).

They're not the same thing - I bet you could use fish inside cmder or iterm.

~~~
PSeitz
Ah okay now I get it, so it's comparable to bash or zsh

------
barosl
I definitely recommend fish to every newcomer to Unix. It has sane defaults,
colorful output, and so many features that work out of the box.

That said, there is a long-standing issue regarding inline environment
variables.[1] Briefly speaking, fish does not recognize the `NAME=value
command` form. So you should use `env` to work around this. This may not be a
deal breaker, but I'm a bit annoyed, and migrated to zsh.

I would call zsh the opposite to fish. It has insane defaults, is highly
customizable, and has so many features that are initially disabled. After
hours of configuring it, I loved it.[2] Since then whenever I set up a new
Unix machine zsh has been the first thing to install.

So, I would recommend zsh for the people who are used to Unix. If not, or you
don't bother to customize it, there's always fish. There is no place for bash.

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

[2] [https://github.com/barosl/baroslized-
settings/blob/master/.z...](https://github.com/barosl/baroslized-
settings/blob/master/.zshrc)

~~~
themodelplumber
Fish is great. I used it for a couple of years, right up until I had to
install a software system that made extensive use of bash scripts that were
incompatible with it. At the time I was in too much of a hurry to figure out
how to tell the software to explicitly use bash, or something along those
lines.

~~~
eridius
Why would a software system that relies on bash not explicitly use bash for
its scripts?

~~~
nilved
Bad developers. For example, I used Arch Linux for a number of years, where
`/bin/sh` is a symlink to bash. Switching that to point to `dash` broke a
number of programs both in the official repositories and the AUR. A lot of
shell scripters can't spot a bashism, and just as many don't know that other
shell syntax even exists.

~~~
eridius
That's a different problem, though. /bin/sh must point to a sh-compatible
shell. fish is not a sh-compatible shell. Therefore, any script using /bin/sh
will _never_ attempt to run as fish (as /bin/sh will never point to fish).

The reason I'm having a hard time imagining how a scripting system that relies
on bash would fail with fish is because I can't imagine how one would actually
write a script that is executed with the user's login shell. There's no #!
line that would do that by accident.

~~~
rquirk
There's just one scenario: a completely absent #! line.

It's an easy fix, just add the line, otherwise 0755 scripts with no #! do
execute using the current shell.

~~~
eridius
That doesn't work for me (in Fish).

    
    
      > cat foo
      echo wat
      > ./foo
      Failed to execute process './foo'. Reason:
      exec: Exec format error
      The file './foo' is marked as an executable but could not be run by the operating system.
    

It does however work in Bash. So this appears to be a bash-ism, rather than an
OS feature.

~~~
rquirk
Ah, bummer. I tested in csh too but not fish.

------
0942v8653
I used to use fish, and emacs. But when I switched to vim, I had to switch
away from fish as well because of its lack of vi bindings. It is a little
disappointing to go back to using bash, but as long as bash-completion is
working, it's not really a big issue. Of course, I do miss the syntax
highlighting. (I would use zsh, but it provides little benefit over bash out
of the box and is slower (oh-my-zsh is unbearably slow to start, too).)

There are a few things that, while I understand why fish is missing them, I
wish would be added:

\- vi-mode, obviously

\- Control+R. It is annoying to have to guess how much you must type before
hitting the up arrow, instead of having it dynamically displayed. Same goes
for zsh vi-mode's ? command.

\- Well more of a removal, but the backslash in single-quoted strings. I'm
used to typing '\', and that's not possible with fish. Additionally, to get
one backslash in any sort of regex (sed, grep), you need four backslashes.

\- Goes without saying, but bash-completion. Fish's completion is mostly
history-based, which is great for repeatedly running the same command, but
terrible for discoverability

\- "$()" and any non-splitting command substitution. Currently, it is
impossible to pass a multi-line string from a command substitution as a single
argument. Which, it may be argued, should be done by piping, but sometimes it
is useful to have stdin.

\- More extensibility in general. I'd like to be able to customize my shell
just as much as I can customize my WM. Probably more.

Honestly, it was easier to go back to using bash than I thought it would be --
it was almost a relief. fish just feels more polished and clean, especially
with regard to escaping, but it misses some very important features.

Edit: I heard that there is a vi-mode now. Sounds interesting, but I don't
really feel like installing it at the moment, and if I ever try another shell
it'll probably be zsh.

~~~
eridius
> vi-mode, obviously

As you said at the end, Fish does have this. I don't know if it's full-
featured enough for you though.

> Control+R. It is annoying to have to guess how much you must type before
> hitting the up arrow, instead of having it dynamically displayed

When you start typing a command-line in Fish that matches a previously-typed
command, it automatically shows the rest of the line as an available
completion, and pressing ^F or the right arrow will complete it for you. The
lack of this functionality actually really kills my ability to use any other
shell.

> Currently, it is impossible to pass a multi-line string from a command
> substitution as a single argument

Not actually true. If you set IFS to '' then that disables command
substitution line splitting. That said, it is not well-known and is rather
awkward. This is a known pain point with Fish today.

> More extensibility in general. I'd like to be able to customize my shell
> just as much as I can customize my WM. Probably more.

It's really hard to know what you're asking for here. What isn't extensible
enough for you? What do you wish you could do that you can't?

~~~
nkouevda
> When you start typing a command-line in Fish that matches a previously-typed
> command, it automatically shows the rest of the line as an available
> completion, and pressing ^F or the right arrow will complete it for you.

^R is more powerful, though; it matches at any point in previous commands, not
just at the beginning.

> The lack of this functionality actually really kills my ability to use any
> other shell.

You can achieve that behavior in readline (which is used by bash, python
shell, etc.) by changing the up/down arrows from previous-history/next-history
to history-search-backward/history-search-forward. In ~/.inputrc:

    
    
      "\e[A": history-search-backward
      "\e[B": history-search-forward
    

Note that you can still use ^P/^N for previous-history/next-history (or you
can remap "\C-p"/"\C-n" as well).

~~~
mintplant
> ^R is more powerful, though; it matches at any point in previous commands,
> not just at the beginning.

That's how it works in Fish as well.

    
    
        user@system ~> echo wow
        wow
        user@system ~> echo something
        something
        user@system ~> wow█
    

...press the up arrow and the current line becomes...

    
    
        user@system ~> echo wow█

~~~
Matumio
In bash, you hit Ctrl-R on the empty prompt and type "w":

    
    
        (reverse-i-search)`w': echo wow
    

Hit return to execute, or any motion keys to start editing. It was the first
thing I missed in Fish.

~~~
TomAnthony
I'm not sure how that is functionally different to mintplant's example?

In fish you just type 'w' hit the up arrow and then hit enter to execute or
any motion keys to edit. The same number of keypresses as well.

Am I misunderstanding?

~~~
dale-cooper
Discoverability. With fish i would have to type something that would be a good
match to the command i want to re-run before pressing up. With bash i type
ctrl+r and start typing and i can continue to type until it's narrowed down to
the correct command.

------
WD-42
Fish is great. For those wondering what advantages is has over zsh+ohmyzsh, I
can say is that by default it provides most the functionality you want without
having to install/tweak anything. Git support is built in (you get a nice git
prompt) there's syntax highlighting, amazing history completion, predictive
commands, man page completions... and so on. To try it on linux, just install
fish and then run "fish", to get back to to bash/zsh just "exit"

Only problem is it's not POSIX so there is some weirdness in command
substitution, logical operators and stuff. So you still script in sh.

~~~
jasonmp85
That was precisely my first question, so thanks for the answer, but I don't
really see how that's enough to switch… I've been using this "cleaned
up/opinionated" fork 'Prezto' for a while now: [https://github.com/sorin-
ionescu/prezto](https://github.com/sorin-ionescu/prezto)

If I'm motivated enough to download and install a shell, why wouldn't I just
clone Prezto and change one config file to turn on syntax highlighting and git
support? Especially when it doesn't bring any "weirdness in command
substitution" and I get the great zsh expansions and completions?

Anyways, I'll try it out (why not?) but the benefit to me wasn't clear from
the page, and even with your direct clarification here I'm seeing more
downsides than zsh + Prezto and not a significant upside.

~~~
nirvdrum
It's been many years since I've use zsh, so I won't pretend to know what's
state of the art with it. I will say that one of the reasons I use fish is
it's incredibly easy to customize. My old bash config just came along with me
from years of use. Some of it I understood, some of it was just culled from
the Internet and kept working, so I kept around (see: prompt customization).
But, other than simple aliases, env var setting, and the occasional function,
I didn't bother much with shell customization. I find fish simple enough that
I can write a new function or tab completion and not have to spend a day
figuring out the bash syntax again.

Writing tab completions in fish is really, really simple. It's the thing that
initially sold me and it's kept me hooked.

The history is more powerful than bash, too. Although I find it sometimes
works against me. E.g., since it tries to guess your command, things you type
in lowercase suddenly turn to uppercase until you manage to disambiguate from
a previous command.

If you're looking for plugins, there's oh-my-fish [1]. Years back, the term
"fish-nuggets" was popular and you'll find repos named that on GitHub with
other configuration. I use a couple plugins, but for the most part I don't
need them. I think part of that is because fish is featureful out of the box
and part of it is because customizing is so easy. I'll usually just add what I
need myself rather than trying to find a general purpose plugin.

Anyway, not a direct answer to your question -- apologies for that. Hopefully
something in there is of use for you, however.

[1] -- [https://github.com/bpinto/oh-my-fish](https://github.com/bpinto/oh-my-
fish)

------
xbryanx
Hyperpolyglot has a nice breakdown of the differences between bash, zsh, and
fish.

[http://hyperpolyglot.org/unix-shells](http://hyperpolyglot.org/unix-shells)

~~~
eevilspock
Hyperpolyglot's typography, colors, layout and simplicity are beautiful.

------
gizi
I do quite a bit of programming in bash. One construct in bash is absolutely
super: process substitution. You can read the output of a program as if it
were a file with the construct: <(myprogram).

Bash is a fine tool, but it has a number of flaws that prevent me from using
it for certain tasks.

* Functions can only return a status number. Functions are always subshells.

* The hashtable (associative array) syntax is unpalatable, unreadable, and a real abomination. I simply don't use it, because it gives me a headache.

* I can never remember the horrible syntax for most string functions.

* You cannot reasonably store an arbitrary json structure in memory. Embedded lists and hashtables are absolutely unwieldy.

* Bash has no concept of FFI (Foreign-function interface). So, you cannot load an external library and invoke functions it it.

These problems are not particularly impossible to solve, but the Bash authors
will probably never do it. Therefore, the final reproach against bash is that
they do not publish their source code in an environment similar to github,
where users can file their issues and improvement requests. In other words,
the bash authors are not in communion with their users.

In what way can the fish shell address these problems?

~~~
e12e
> One construct in bash is absolutely super: process substitution. You can
> read the output of a program as if it were a file with the construct:
> <(myprogram)

Actually had to look that one up[1] -- unfortunately you're right, it's not
posix (I don't think I would've tried it in a [ed: non-interactive] script,
but I agree it is very nice).

I wonder if you could make a function as a work-around, something like:

    
    
        r() {
          #r(first some args <(second other args))
          # Use a fifo:
          ff=$(mktemp fifo)
    
          # might as well use that for parsing the commands...
          echo "$*" > $ff
          first=`sed -re 's/\((.*) <\(.*/\1/p' < ${ff}`
          echo "$*" > $ff
          second=`sed -re 's/\(.* <\((.*)\)/\1/p' < ${ff}`
          ${second} > $ff &
          ${first} < $ff
        }
          

Adjust for parsing the direction of the <() vs >() etc... Not particularly
robust, and the above is un-tested... Just an idea.

I'm not convinced trying to parse shell command lines for macro functionality
is a good idea in general...

[1] [http://mywiki.wooledge.org/Bashism](http://mywiki.wooledge.org/Bashism)

~~~
unhammer
Apparantly it's built-in as psub for the <() case (I was looking for the same
thing
[https://news.ycombinator.com/item?id=9569730](https://news.ycombinator.com/item?id=9569730)
), not sure about >()

~~~
e12e
Indeed. Came across this:

[http://arstechnica.com/information-
technology/2005/12/linux-...](http://arstechnica.com/information-
technology/2005/12/linux-20051218/4/)

I hadn't really thought about that echo'ing the filename might be useful, but
this is pretty equivalent to how things work in bash -- with "diff <(some)
<(other)", diff gets two temporary file-handles to two fifos -- that are later
cleaned up by the shell. As most good ideas, obvious when you think about it
:-)

------
donatj
Fish not being bash compliant was a deal breaker for me.

I use zsh with [https://github.com/zsh-users/zsh-syntax-
highlighting](https://github.com/zsh-users/zsh-syntax-highlighting) zsh fish
like syntax hilighting and am much more happy.

~~~
saidajigumi
> Fish not being bash compliant was a deal breaker for me.

Would you mind elaborating here? I'm very honestly curious how the deal gets
broken for you.

To explain my curiosity, I've long since come to the opinion that we're in the
midst of a long, somewhat painful split caused by a design dissonance over
improving the interactive shell UX versus creating a better environment for
scripting.

We've been building alternatives around the scripting problem for ages now,
perhaps most notably starting with Perl's ascendance. That legacy continues
with Python, Ruby, and now many other tools. I'll still reach for bash/zsh as
a scripting tool, but only when the situation absolutely will not admit an
extra dependency. In my experience, the pain factor goes up far more quickly
with code complexity when it's all just gotta be done in POSIX/bash land.

As for the interactive shell UX, fish is notable for simply putting its foot
down and just saying "no" to the scripting side. It pushes out POSIX scripting
compatibility as an external feature. Calling bash is now on the same level as
calling out to {Perl, et. al.}. Whether or not fish is your cup of tea, it's
inspired a bunch of competing work in the traditional interactive shells.

At the current time, the above efforts are simply going in different
directions. We have numerous better options for rich automation than POSIX
shell scripting. Likewise, shell scripting just gets in the way of creating
better, extensible developer/admin CLI environments. It has too many quirks
(hi, quoting hell!) and limitations (real data structures, please) to work
well for an extensibility platform.

~~~
mbq
When used as a login shell, shell is expected to _source_ some init scripts to
fix PATH, locale and stuff; if a particular distro is not written with
alternative shells in mind this will fail, esentially making you use two
shells which is cumbersome enough to be a deal breaker.

~~~
saidajigumi
Thanks for the input; that's a good point. For my part, I don't tend to run
into this, as I either run a stock distro shell or I go all the way and
install the half-sentient metavirus that's my homedir repo. Which I've taught
to deal with such vagaries rather efficiently over the years.

------
Sphax
Fish is great. I've been using it for close to 3 months now, was using zsh
with prezto before.

I find Fish to be simpler to use and more powerful by default. You can
probably have a zsh or maybe even bash setup which does the same fish does,
but I don't want to do that.

~~~
distracteddev90
Would you mind expanding on what fish does out-of-the-box that prezto neglects
or hides behind configuration? I am in a similar boat as you and was just
wondering what I had to look forward to as a prezto user.

~~~
jeffcox
The biggest thing that swayed me to stick with (and optimize/customize) Prezto
was the fact that most of the systems I work with have zsh, or a relatively
modern version of it available in repos. Can't say the same for fish.

~~~
ufo
If you don't mind adding external repositories, you can get up to date
versions of fish for most distros.

[http://fishshell.com/#get_fish_linux](http://fishshell.com/#get_fish_linux)

~~~
jeffcox
More a question of corporate best practices than minding, but I appreciate the
link!

------
talex5
I've been using fish for a few months now (switched from zsh). Really nice to
have good defaults and minimal configuration, and the suggestions based on
previously entered commands are great.

The main issues I have compared to zsh are:

\- No bracketed paste mode. If I select multiple lines of text and middle-
click-paste into zsh, it adds the whole lot as a multi-line input and lets me
review the commands before pressing Return. fish just starts blindly executing
them, which can cause accidents.

\- Chaining commands is harder. In zsh `foo |& less` pipes stdout and stderr.
Also, fish's `foo; and bar` is longer than `foo && bar`.

\- Hashes in words start a comment in fish. e.g. `opam pin repo#branch` is
treated as `opam pin repo`, pinning the wrong branch. zsh only treats # as a
comment at the start of a new word.

\- While completion history and `set -U` are really useful, it sometimes
forgets everything and I have to start again, which is quite annoying.

On the whole, very happy with it though!

------
tambourine_man
Since Apple seems forever stuck on an ancient Bash version (due to GPL 3, I
believe), I keep hoping they switch to Fish (or a home built solution, à la
Swift, which could be interesting) with every OS release.

~~~
robin_reala
Fish does feel very Appley to me. I wouldn’t be surprised.

~~~
pooriaazimi
Well, "ridiculous_fish", the guy who sort of revived the fish shell is an
engineer on the AppKit team at Apple:
[http://ridiculousfish.com](http://ridiculousfish.com)

I remember installing and using fish 4 or 5 years ago; it was not a great
experience -- but after he "took over", I switched and couldn't be happier
with fish.

~~~
serth
Interesting! My impression was that Apple engineers were prohibited from
building anything outside of work.

~~~
waterhouse
According to Wikipedia[0], fish was originally created by Axel Liljencrantz in
2005. The commit history from GitHub does go back that far (I imagine it was
imported somehow), so I assume it's complete. The first commit from
ridiculous_fish is in 2011.

So if there is such a policy at Apple, I would expect that it doesn't prohibit
contributing to already-public projects.

[0]
[http://en.wikipedia.org/wiki/Friendly_interactive_shell](http://en.wikipedia.org/wiki/Friendly_interactive_shell)

------
ahmetmsft
For those who like the autosuggestion feature of Fish but can't leave oh-my-
zsh, there's a plugin for that: [https://github.com/tarruda/zsh-
autosuggestions](https://github.com/tarruda/zsh-autosuggestions)

~~~
wldcordeiro
For those who use antigen you can add this line to your .zshrc to install
this.

antigen bundle tarruda/zsh-autosuggestions

------
distracteddev90
I can clearly see the difference between Fish and regular ol' bash, but
struggling to see what value Fish adds above prezto/zsh. Could anyone help me
out here?

~~~
ufo
Fish breaks compatibility with traditional shell languages. The syntax is a
bit different, the variable expansion rules are a bit different, etc. It also
gets rid of a bunch of features and configuration options, such history
expansion ("$!!").

The positive side of this is that fish is very simple and has a very pleasant
experience out of the box. And this is not just about having "good defaults"
\- its also about having a good design that encourages having one way to do
things. That said, an interactive shell is a very personal thing. The only way
to really get a good feeling is to install and check it out.

------
bajsejohannes
I've used fish shell for about a year and I love it. I recently stumbled upon
the design document, which summarizes well why I like it so much:
[http://fishshell.com/docs/2.0/design.html](http://fishshell.com/docs/2.0/design.html)

I actually think that design document could be a good start for a lot of
projects.

------
qznc
Yay, I am specifically waiting for "New `fish_preexec` and `fish_postexec`
events are fired before and after job execution respectively" [0] It allows to
implement something like undistract-me [1] for fish.

[0] [https://github.com/fish-shell/fish-
shell/issues/1549](https://github.com/fish-shell/fish-shell/issues/1549) [1]
[http://mumak.net/undistract-me/](http://mumak.net/undistract-me/)

edit: Just installed the beta and implemented it (status WorksForMe)
[https://github.com/qznc/dot/commit/8cf55564383ed93af148234d2...](https://github.com/qznc/dot/commit/8cf55564383ed93af148234d2e6b3826e7c6f325?diff=unified)

------
cabalamat
>Sane Scripting -- fish is fully scriptable, and its syntax is simple, clean,
and consistent. You'll never write esac again.

I can already do sane scripting, with Python. I suspect that as soon as I try
to to anything slightly complicated, Python leaves fish scripting behind.

------
kolev
Fish is definitely good, but not great enough to justify a switch from Bash. I
maintain tens of thousands of lines of Bash scripts and was considering
switching to Fish once, but decided it wasn't worth it.

When you compare the *nix shells to PowerShell, they feel prehistoric. We all
use grep, sed, awk, and the likes, but don't you get tired of having to deal
with unstructured data and gross limitations of the shell like basic data
structures. Yes, the purpose of the shell is to be quick and dirty, but it
doesn't take that much to add some programming sanity and some standards for
structured data! There's a port of PowerShell to Mono, Pash [0], but it's so
heavy in terms of requirements and has somewhat unclear future. Of course,
there's also Xonsh [1] and Xiki [2], but they are pretty new.

[0] [https://pash-project.github.io/](https://pash-project.github.io/)

[1] [http://xonsh.org/](http://xonsh.org/)

[2] [http://xiki.org/](http://xiki.org/)

P.S. One of my favorite Fish feature is Event Handling [3].

[3]
[http://fishshell.com/docs/current/#event](http://fishshell.com/docs/current/#event)

~~~
zaphar
I've tried to use and get comfortable with Powershell but it's insistence on
types and overly heavy syntax just get in the way for my primary use case for
shell scripting. (e.g. quick and dirty hacks)

I don't in fact get tired of unstructured data and the limitations of the
shell like basic data structures because nine times out of 10 the data I have
to work with in a shell is exactly that. Unstructured and basic. Not because
of the shell but because the source of that data provides it that way.

Powershell with it's intense focus on fancy datastructures makes something
like

    
    
        sed '/foo/d'
    

unecessarily hard and that's exactly the sort of thing I use my shell for.

If I want something more powerful for working with structured data I'll use
Python or Julia.

~~~
kuma4
PS> echo foo,bar,baz | ? { $_ -ne "foo" }

The sed command is not a shell. You can use sed in PowerShell.

~~~
zaphar
Yeah but sed isn't present by default in Powershell. in Unix systems it is and
Powershell's ecosystem makes the approach sed uses a second class citizen.

------
Alupis
Seems like their slogan might be a little limiting.

> fish is a smart and user-friendly command line shell for OS X, Linux, and
> the rest of the family.

I'd wager majority of OSX users are not going to be changing shells, but by
specifically enumerating OSX as the first example use, it feels like the
others are mere afterthoughts.

Would be better put:

> fish is a smart and user-friendly command line shell for the entire *nix
> family.

~~~
cheese1756
While that wording is more precise, the current wording is better for
promoting the software. Ordering by market share makes sense, and users who
are quickly scanning the page for compatability information don't need to make
the connection between OS X or Linux and *nix, and can instead recognize their
current system easily.

If this were documentation the change should be made, but it's probably not
the right move on a website focused on promotion.

------
shirro
I tried really hard to use Fish for awhile and if the shell was just history,
completion and sane defaults (and it is for some people) it would have a very
good case. But not being even remotely compatible with bash drove me nuts as
the shell is my REPL.

------
samspot
Is there a way to use this in the excellent Git Bash for Windows? Because Git
Bash is amazing and I don't see myself going back to cygwin anytime soon. I
understand how they could be very incompatible because of the way Git Bash is
built.

------
_jomo
I've been using fish for at least a year now and I absolutely love it,
altogether with oh-my-fish [0].

I don't mind the incompatibility to bash, but using "; and" instead of "&&" is
a little annoying.

Everything else is great.

It actually auto-completes remote hosts and paths when you type ssh or scp
commands! It also fuzzy-completes filenames when you're lazy (or have typos in
them) and a bunch of other neat things.

The up-key function after typing in parts of a command and ^F have probably
saved me hours of time wasted in bash.

0: [https://github.com/bpinto/oh-my-fish](https://github.com/bpinto/oh-my-
fish)

------
iagooar
3 years using Fish shell now, and wouldn't go back to anything else. The
autocompletion (including fuzzy matching) feature is just so vastly better
than in other shells.

I must say I am not a huge shell wizard and use only a handful of custom
functions, but I've found shell to be very pleasant to work with and would
recommend it to any web developer who doesn't get "dirty" with shell scripting
a lot.

The only problem I had was that I had to explicitly set the shell used by vim
in order to make vim plugins / configs work properly by using this line:

set shell=/bin/bash

------
BorisMelnik
I've been a Linux command line (bash) user for 20+ years now and I must say, I
would really consider switching to this. I haven't even started to dig into
the features yet, but the filename and parameter completion alone is enough to
stop me from pulling my hair out.

Filenames are getting very long w/ so many special characters, this is great.
I also like the idea of having a web based config. I really won't miss
wrestling with bashrc and bashconfig in vi. Definitely will try this.

~~~
aerique
I've been using Unix (and mainly Linux) for 20+ years as well. First using
bash, then zsh the last couple of years and I recently switched to fish. The
switch was fairly effortless and it took maybe 2 days to not even notice the
differences anymore. I do have to look up some things now and then but overall
it has been an improvement.

What I like about fish shell is the same why I use the i3 tiling window
manager. It has sane defaults and it clicks with how expect things to work,
how I would design them. Sane defaults mean a minimal config file so it's easy
to look up problems and change things.

I'd at least try it out if I were you.

~~~
BorisMelnik
how long have you been using the i3 tiling window manager?

------
black_knight
Fish and zsh grew out of bash, which again was a free replacement of Bourne
Shell — but from Bourne Shell there was another interesting development,
namely rc[0]. rc was developed at Bell Labs as the successor of Bourne shell.
I usually prefer its syntax to the bash derivatives when scripting. It has a
much cleaner feel to it.

[0] [http://plan9.bell-labs.com/sys/doc/rc.html](http://plan9.bell-
labs.com/sys/doc/rc.html)

------
jordanpg
I'll switch to one of these new-fangled shells if I ever master bash.

In any case, bash -- in one of its many forms, colors, and sizes -- is what I
usually find myself in front of.

------
lamentspants
Their shitty webpage still requires javascript, though!

~~~
_jomo
and this is 2015, why are people still against JS?

~~~
cbd1984
Because it's bad practice to demand people use it when it's not required.

~~~
pnut
Um, pretty sure they can make whatever demands they want on their own website.

JS is standard issue in 2015, come on out of the bunker.

~~~
cbd1984
If they can't write a page without useless frills, they can't write a shell
without useless frills.

Useless frills are buggy and slow.

------
unhammer
Pretty flashy :-) I like how it told me to use () when I tried typing $(), and
the autocompletion is quite impressive.

However, how do you work around the lack of <() and >()? E.g. if I want to do
the equivalent of

    
    
        $ diff <(xzcat foo.xz) <(xzcat bar.xz)
    

?

EDIT: nevermind, I see the fish version is

    
    
        $ diff (xzcat foo.xz|psub) (xzcat bar.xz|psub)
    

which actually does the mkfifo dance for you :-)

------
jwarren
I used fish for at least a year, maybe more. I eventually switched away to
zsh. Whichever theme I used, rendering the status of git repos took ages, and
the breaks from Bash syntax were just a bit too much.

I loved the overall friendliness though, it was a genuine pleasure to use for
the most part. I hope to use it as my default shell again some time in the
future.

~~~
bert_cwchang
> Whichever theme I used, rendering the status of git repos took ages I don't
> think this is fish's issue. In fact, this will happen in any shell (bash /
> zsh) if your git repo is big. The solution is either (0) speed up `git
> status`-like commands by enable git cache, or (1) use async showing git repo
> status just like prezto.

~~~
dkns
Would you mind elaborating a bit? When I switched to zsh I started with oh-my-
zsh but soon uninstalled it as it was too much for my needs. I started again
with simple .zshrc file and I'm hesitant to going back to frameworks like
prezto but working on a really big project in git slows down zsh noticeably.

------
landr0id
The autosuggestions looked pretty sweet! Here's something that enables similar
functionality in zsh: [https://github.com/tarruda/zsh-
autosuggestions](https://github.com/tarruda/zsh-autosuggestions)

------
anonfunction
Fun with fish, frogs and fortunes:
[https://gist.github.com/montanaflynn/04246fc5da998d15e713](https://gist.github.com/montanaflynn/04246fc5da998d15e713)

~~~
qznc
[https://github.com/qznc/dot/blob/master/config/fish/config.f...](https://github.com/qznc/dot/blob/master/config/fish/config.fish#L152)

I use something similar: tux instead of frogs and a personal fortunes file.
Mine also prints the current date, hostname and uptime.

~~~
anonfunction
Nice! I've actually adopted a minimal approach as of late:
[https://gist.github.com/montanaflynn/da1f0565c95a5a37b458](https://gist.github.com/montanaflynn/da1f0565c95a5a37b458)

------
wodenokoto
Looks interesting and great timing. I got super annoyed today when I saw that
the latest version of gnome terminal in Ubuntu stopped supporting changing tab
titles via the GUI.

~~~
semi-extrinsic
The shell is completely independent of the terminal emulator. Fish is the
former, while you're complaining about an example of the latter. (My
recommendation for a terminal emulator would be urxvt with the tabbedex
extension. YMMV.)

~~~
psibi
I have seen many people recommending urxvt. What is the advantage of it
compared to gnome-terminal ? The last time I tried it, it's default font size
was too small and I didn't like the font. Does it take some fiddling
(configuration etc) with urxvt to bring it a minimal usable state ?

~~~
gh02t
> Does it take some fiddling (configuration etc) with urxvt to bring it a
> minimal usable state

Yes. urxvt is pretty minimal and will likely be rather ugly by default.
However, you can customize pretty much everything via editing your Xresources
file.

In terms of advantages over gnome-terminal... it's lighter weight and
considerably faster (though tbh, speed isn't that important for most people).
It doesn't depend on any Gnome services/libraries, so it integrates better
with e.g. a tiling WM. It's stable, in the sense of the developers won't cut
<insert feature> out. The configuration is very flexible and it's extensible.

However, to be honest it's not for everybody. I wouldn't even say it's for
"power users", it's really mostly for minimalists and the default
configuration is incredibly sparse. If you're dissatisfied with gnome-
terminal, I'd probably recommend roxterm or lxterminal instead. IMO, urxvt is
more one of those "I already know I want it and I know why I want it" kind of
things. That said, I've been using it for a few years and I really like it.

~~~
0942v8653
So far, gnome-terminal is the only one* I've seen that can rewrap text
properly when the window width changes. Does urxvt do that? Is there something
lighter (than gnome-terminal) that does?

* not the only one, but I'm not sure finalterm is really ready to use yet, and it's certainly not lightweight.

~~~
nandhp
I just checked, and it seems to support rewrapping without any trouble.
(Though, oddly enough, GNOME Terminal 2.31 doesn't.)

~~~
0942v8653
I'm on 3.14. Thank you, I will probably like that much better.

Edit: Hmm, it doesn't seem to work properly in 9.20. Well, I should probably
be using tmux anyway, which does fix the problem.

------
MindTooth
Been using it for almost two years I guess. Find it really nice. Would one day
love to be more able to script with it; adding more features for my own needs.

Give it a try at least :-)

------
snnw
2.2 beta 1 was released last week. Testers welcome!

~~~
aldanor
Has the bug with removing autoloaded functions been fixed yet?

~~~
ridiculous_fish
If you mean the fact that a removed autoloader function may be autoloaded
again, then yup, that's fixed in 2.2. Here's the issue that tracked it:
[https://github.com/fish-shell/fish-shell/issues/213](https://github.com/fish-
shell/fish-shell/issues/213)

------
synthecypher
Comes around once in awhile.

It's good, but quite a few things are incompatible from what I remember after
trying it a year ago.

------
hndl
How does this compare with zsh + ohmyzsh?

~~~
0942v8653
Much faster, but much less configurable. If you have a decent config on
ohmyzsh already, and it doesn't take too long to start up (you have an SSD),
there is little point in switching to fish IMO. Especially if you use a lot of
these things: [https://github.com/fish-shell/fish-
shell/issues?q=is%3Aissue...](https://github.com/fish-shell/fish-
shell/issues?q=is%3Aissue+sort%3Acomments-desc+is%3Aopen)

~~~
nirvdrum
I've been using fish for a while, but generally don't go crazy customizing my
shell. What makes it less configurable? It'd be helpful to know what pitfalls
to avoid.

------
cbd1984
And their webpage is broken

------
g8gggu89
You should have called it the clamshell.

