I tried fish for a while but as someone who heavily used bash before I couldn't get used to the new language. I also didn't feel they the language was much better than bash, at least for my usage. But I loved the default automatic coloring of arguments, underlining of files, etc.

Later I found fizsh, which I love and still use as default shell now. It's basically a configuration around zsh adding the colors, completions, and other good stuff inspired by fish to zsh. Can really recommend it for those who are used to zsh or bash but want their CLI to be more readable. Colors especially help with big command line arguments to show where they start and end, and keeping track of complex stuff like loops and conditional logic in your commands.

fizsh sounds really cool, but the last commit was 7+ years ago. do you run into any issues? https://github.com/zsh-users/fizsh

I never noticed any issues, actually. I guess the zsh base is solid and stable.

Fish is just excellent out of the box. It's a little tragic how path dependent we are on flawed terminal experiences designed 40 years ago.

For POSIX: I leave Bash as the system shell and then shim into Fish only for interactive terminals. This works surprisingly well, and any POSIX env initialisation will be inherited. I very rarely need to do something complicated enough in the REPL of the terminal and can start a subshell if needed.

Fish is nicer to script in by far, and you can keep those isolated with shebang lines and still run Bash scripts (with a proper shebang line). The only thing that’s tricky is `source` and equivalents, but I don’t think I’ve ever needed this in my main shell and not a throw-away sub shell.

I often write multi-line commands in my zsh shell, like while-loops. The nice thing is that I can readily put them in a script if needed.

I guess that somewhat breaks with fish: either you use bash -c '...' from the start, or you adopt the fish syntax, which means you need to convert again when you switch to a (bash) script.

I guess my workflow for this is more fragmented. Either I’m prototyping a script (and edit and test it directly) or just need throwaway loop (in which case fish is nicer).

I also don’t trust myself to not screw up anything more complex than running a command on Bash, without the guard rails of something like shellcheck!

I used to do it this way, but then having the mentally switch from the one to the other became too much of a hassle. Since I realized I only had basic needs, zsh with incremental history search and the like was good enough.

I don't care for mile-long prompts displaying everything under the sun, so zsh is plenty fast.

After 10 years on zsh I finally switched 6 months ago and I haven't looked back. If I need POSIX, I'll just run scripts with the right shebang or pipe it to sh.

I've been using fish for nearly 10 years.

First, there are some ways to make fish more compatible with bash.

If you want to do some shell scripting in fish, or running other people's shell scripts (or commands) this may aid you since you wouldn't have to port them (or take less time to port them over).

You can achieve this with a plugin system such as 'oh my fish' or 'fisher'. But, as always, it adds complexity (and bloat :P), you'll need it on every fish shell (including remote systems), etc.

It is a bit akin to having nvim with plugins versus being able to use vi. Sometimes, you're going to need to be able to use the latter.

Also, to people who recently adopted fish: fish has been made more and more compatible with bash throughout those years.

FWIW, I use fish with starship these days.

When I'm in fish and I want to run a bash script I just... call it with bash :-)

./script.sh

and script.sh just starts with #/bin/bash

I'm simple

If I use fish, I want to make use of it, and that means I will want to convert scripts, or simply learn to write scripts compatible with fish.

Shell scripts from third parties stick with whatever shell they were written for (ie. /bin/sh or /usr/bin/env bash), and commands copy/pasted from the internet are either quickly executed with bash (one-off) or ported over. Because I like to have such in my history (fish is configured to use atuin), I want to keep using the same shell, so I try to stick with fish. If I cannot convert a command (usually a bunch of commands) to fish, it is PEBCAK and a learning curve/experience.

As for tmux, that is solid advice, because it also allows to stick with a shell which is known to work. I've come to like zellij with alacritty, with zellij the option is default_shell. But now that I use ghostty, I don't use a terminal multiplexer locally any more; only remotely. And there I still use tmux.

This wouldn't work if the script is meant to be sourced (to set environment variables) isn't it?

No, it doesn't.

The way I actually have things setup, in case it helps. I don't change my default shell. I actually default to pretty much working within tmux. So, I kept my default shell to what the OS brings, then in my tmux config, I have,

    # set shell
    set -g default-shell /opt/homebrew/bin/fish

This means, that when I start my terminal, it drops me to zsh (macOS default). Then when I run tmux, it opens fish. The nice thing is that I inherit the environment of zsh.

I have my .zshrc and my .bashrc sourcing a .shellrc file which contains most of my env stuff. This keeps random utilities that write to .bashrc and zshrc working within fish too.

It’s only takes a second to run a child bash shell when you need something posix

I have been using fish for 10 years now as my main shell and it is just perfect.