From Zsh to Fish Shell: A Faster, Friendlier Terminal Experience

Fahmi Aulia Rahman • • 8 min read

TL;DR

I ditched Zsh with Oh My Zsh and switched to Fish Shell with Tide prompt. Fish feels snappier, comes with smart features built-in (autocomplete, syntax highlighting, auto-suggestions), and doesn’t require plugin bloat to feel productive. If you spend most of your time in the terminal like I do, this switch is worth considering—especially if you’re tired of waiting for your shell to start up.

The Problem with My Old Zsh Setup

For years, I’ve been a terminal power user. I use Yazi instead of Finder, Neovim for coding, and basically live in my shell. My previous setup was Zsh with Oh My Zsh + Powerlevel10k, which looked beautiful, but there was one persistent annoyance: startup lag.

Every time I opened a new terminal window or tab, there was a noticeable delay. Sometimes it felt like the prompt was taking 2-3 seconds just to appear. It wasn’t catastrophic, but when you open terminals dozens of times per day (especially during development work), those milliseconds add up. I’d already stripped down my Oh My Zsh configuration to remove some plugins, but it was still not as snappy as I wanted.

The root cause? Plugin bloat. Even a “minimal” Oh My Zsh setup loads a framework, themes, and various plugins on every shell startup. Each addition adds overhead—and Zsh’s completion system (compinit) is particularly slow.

Why Fish Shell?

I started looking at alternatives and kept seeing Fish mentioned in communities as “the friendly shell that just works.” The more I researched, the more it made sense:

1. Built-in, Intelligent Features

Fish doesn’t require you to install Oh My Zsh, plugins, or frameworks to get nice features. Here’s what comes out of the box:

  • Auto-suggestions: As you type, Fish suggests commands from your history in light grey. Just press the right arrow or Ctrl+F to accept it. This is always on and incredibly convenient.
  • Syntax highlighting: Commands are highlighted in real-time. Invalid commands appear in red immediately, so you catch typos before pressing Enter.
  • Tab completion: Fish offers smart tab completion for commands, file paths, and even command-specific options with descriptions. You don’t need to manually write completion scripts for most tools.
  • Git integration: The default prompt includes git status without extra configuration.

2. Performance

This was the big sell for me. Fish’s startup time is noticeably faster than a configured Zsh setup. While raw shell startup (with no config) shows Fish slightly heavier, once you add typical user configurations:

  • Fish with a clean config: snappy, visible responsiveness
  • Zsh with Oh My Zsh + plugins: noticeable lag, especially on slower systems or when launching many shells in quick succession

The difference becomes even more pronounced on older machines or when running in constrained environments. I haven’t measured exact benchmarks on my machine, but the subjective experience is immediate—new shell windows appear instantly.

3. Simpler Configuration

Instead of managing multiple configuration files (.zshenv, .zprofile, .zshrc, etc.), Fish uses a single ~/.config/fish/config.fish file. The configuration language is also more readable than Bash-style scripting.

Functions and abbreviations are easier to write. Fish’s syntax is deliberately less cryptic than Bash/Zsh—you’re not fighting shell scripting quirks.

My New Setup: Fish + Tide

After switching, I replaced my Powerlevel10k + Oh My Zsh with:

  • Fish Shell as the core
  • Tide as the prompt theme
  • Fisher as the plugin manager (minimal plugins, just what I need)

Installing Fish

On macOS:

brew install fish

Set it as your default shell:

chsh -s /opt/homebrew/bin/fish

On Linux (Ubuntu/Debian):

sudo apt install fish

Then set as default:

chsh -s /usr/bin/fish

Setting Up Tide

Tide is a modern prompt for Fish, inspired by Powerlevel10k. Installing it is dead simple:

fisher install IlanCosman/tide

After installation, run the configuration wizard:

tide configure

This gives you an interactive menu to choose your prompt style, colors, and which elements to display (git status, command duration, etc.). It’s much more straightforward than hand-editing Powerlevel10k configs.

I chose a style that shows:

  • Username and hostname
  • Current directory with git branch
  • Command execution time (when commands take more than 100ms)
  • Exit status of last command (red indicator if failed)

The whole thing took maybe 5 minutes to set up exactly how I wanted it.

Why Not Other Options?

I looked at alternatives like Starship (which works with Fish too) and the default Fish prompt. Both are great, but:

  • Starship is a universal prompt (works with any shell), which is cool but adds configuration complexity if you only use Fish
  • Default Fish prompt is actually really functional, but I wanted something more visually polished
  • Tide hits the sweet spot—it’s purpose-built for Fish, has good async loading for performance, and is easy to configure

The Fish Shell Difference

Working with Fish has revealed some genuinely nice design decisions:

Readable Syntax

Loop syntax is straightforward:

for file in *.txt
    echo $file
end

No cryptic done or fi keywords. It feels more like pseudocode.

Smart Tab Completion

When I type a command and press Tab, Fish shows available options with descriptions. For example, with git, I see all available git subcommands. With file paths, it intelligently completes what exists.

No POSIX Baggage

Fish intentionally breaks POSIX compatibility in interactive mode. This means it can make usability choices that POSIX shells can’t. For interactive use (which is what matters), Fish prioritizes convenience over compatibility.

(Note: If you need to run scripts written in strict POSIX shell, you can still use Bash for that. Fish doesn’t prevent you from using other shells for automation.)

Abbreviations Over Aliases

Fish uses abbr instead of alias. Abbreviations expand as you type, so if I type gco, it expands to git checkout as I type it. This means I can see and edit the expanded command before pressing Enter. It’s a small thing, but it’s more intuitive than traditional aliases.

The Workflow

Here’s how my typical terminal day looks now:

  1. New shell window opens → Tide prompt loads instantly, no perceptible lag
  2. Typing commands → Auto-suggestions kick in, syntax highlighting catches errors, I rarely have to type full commands
  3. Tab completion → Smart suggestions appear immediately, often knowing what arguments I need
  4. Git work → Prompt shows git status without me having to check manually

All of this works by default. I haven’t needed to install extra plugins or mess with configuration files constantly. The shell stays responsive even when I’m doing heavy terminal work.

Challenges and Trade-offs

Fish isn’t perfect. Here’s what I had to adjust to:

  • Less POSIX compatible syntax: Commands like cmd1 && cmd2 work fine now, but some older shell scripts might need tweaking. Not a big deal for interactive use.
  • Different scripting paradigm: If you’ve written Bash functions before, Fish functions have a different feel. But honestly, it’s more readable once you get used to it.
  • Plugin ecosystem smaller than Zsh: There are fewer plugins available, but that’s actually a feature—less bloat to choose from.

I haven’t hit any real blockers. Everything I need to do works smoothly.

Should You Switch?

If you:

  • Live in your terminal (development, system administration, DevOps)
  • Use a shell dozens of times per day
  • Want features that “just work” without configuration
  • Are tired of shell startup lag

Then yes, Fish is worth trying. The migration takes maybe 30 minutes, and if you don’t like it, you can always switch back.

If you:

  • Rely on scripts written in Bash/POSIX shell
  • Need maximum compatibility across different systems
  • Are deeply invested in a Zsh configuration you love

Then stick with what you have. It’s not a religious choice—pick the tool that fits your workflow.

Final Thoughts

Switching to Fish was one of those small quality-of-life improvements that doesn’t sound dramatic but genuinely makes the experience better. I’m not using a slower machine or waiting for tooling anymore. My terminal feels responsive, my prompt is beautiful without being bloated, and I spend less time fiddling with configuration files.

If you’re in the terminal as much as I am, it’s worth the experiment. Fish + Tide has become my sweet spot between functionality and simplicity.

References

About the author

Portrait of Fahmi Aulia Rahman

Fahmi Aulia Rahman

Software Engineer

Software engineer with 6+ years under the hood with new dad vibes — shipping cool stuff, learning out loud and keeping it real.