Shell Setup in 2026: Starship, Plugins, Fish

Your Terminal Deserves Better Than 2016

Oh My Zsh was a revelation when it came out. One install, hundreds of plugins, a fancy prompt — suddenly your terminal felt alive. If you’re running it right now, it still works. Nobody’s coming to take it away.

But here’s the thing: it’s slow. Not “barely noticeable” slow — we’re talking 200–600ms startup time slow, depending on how many plugins you’ve accumulated over the years. That’s the lag between hitting Enter and actually seeing a prompt. Every. Single. Terminal. Tab.

The ecosystem has moved on. In 2026, you can have a faster, smarter terminal experience without blowing up your existing config — and you don’t even need to switch shells to get there.

Starship: One Prompt to Rule Them All

Starship is a cross-shell prompt written in Rust. You install one binary and it works in bash, zsh, fish, nushell, PowerShell — whatever you’re running. The prompt is fast because it’s compiled, not interpreted, and it’s smart because it auto-detects your context: git branch, Python virtualenv, Node version, Kubernetes context, whatever’s relevant to the directory you’re in.

curl -sS https://starship.rs/install.sh | sh

Then add the init line to your shell config. For zsh:

eval "$(starship init zsh)"

For bash:

eval "$(starship init bash)"

That’s it. You now have a context-aware, fast, good-looking prompt.

Why Not Powerlevel10k?

Powerlevel10k is excellent, but it’s zsh-only and traditionally required a Nerd Font for the fancy glyphs. Starship works out of the box without any special fonts (you can add them if you want, but you don’t have to). More importantly: if you ever try fish or nushell, your Starship config comes with you. No reconfiguration needed.

Starship Config

Config lives at ~/.config/starship.toml. Here’s a sensible starting point:

# Don't print a new line at the start of the prompt
add_newline = false

[character]
success_symbol = "[›](bold green)"
error_symbol = "[›](bold red)"

[git_branch]
symbol = " "
truncation_length = 20

[git_status]
ahead = "⇡${count}"
behind = "⇣${count}"
modified = "!"
untracked = "?"

[directory]
truncation_length = 3
truncate_to_repo = true

[nodejs]
symbol = " "

[python]
symbol = " "

[docker_context]
symbol = " "

Run starship explain to see every module that’s active for your current directory. Run starship timings to see what’s taking the most time.

Three Plugins That Actually Matter

You don’t need Oh My Zsh’s 300 plugins. You need these three, and they each solve a real problem.

zsh-autosuggestions

Ghost text completions based on your command history. You start typing docker compose up and the full command appears in grey — hit the right arrow key to accept it. It’s the single most useful shell plugin in existence and you’ll feel its absence immediately on any machine that doesn’t have it.

git clone https://github.com/zsh-users/zsh-autosuggestions \
  ~/.zsh/zsh-autosuggestions

Add to ~/.zshrc:

source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh

fast-syntax-highlighting

Real-time syntax colors as you type. Valid commands go green, invalid ones stay red. You’ll catch typos before running them and you’ll never accidentally run a command that starts with a comment # thinking it’ll do something.

git clone https://github.com/zdharma-continuum/fast-syntax-highlighting \
  ~/.zsh/fast-syntax-highlighting

source ~/.zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh

These two solve different problems but they work better together.

zoxide learns which directories you actually visit and lets you jump to them by partial name:

# Install zoxide
curl -sSfL https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh

# Install fzf
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf && ~/.fzf/install

eval "$(zoxide init zsh)"

Now z proj takes you to ~/dev/projects because you’ve been there a hundred times. z api takes you to whatever API directory you visit most. It’s cd with a memory.

fzf is a fuzzy finder that upgrades everything. The big one: Ctrl+R for history search becomes an interactive fuzzy search through your entire command history instead of a dumb reverse-scroll. It also integrates with file pickers, git log browsers, and anything else that takes a list of items.

Putting It Together: Minimal .zshrc

Here’s a clean starting point that combines everything above. Clone the repos first (see above), then:

# Starship prompt
eval "$(starship init zsh)"

# zoxide (smart cd)
eval "$(zoxide init zsh)"

# fzf keybindings and completions
[ -f ~/.fzf.zsh ] && source ~/.fzf.zsh

# Plugins
source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh
source ~/.zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh

# Autosuggestions config
ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE="fg=#666666"
ZSH_AUTOSUGGEST_STRATEGY=(history completion)

# History settings
HISTSIZE=50000
SAVEHIST=50000
HISTFILE=~/.zsh_history
setopt SHARE_HISTORY
setopt HIST_IGNORE_DUPS
setopt HIST_IGNORE_SPACE

# Useful aliases
alias ll="ls -lah"
alias ..="cd .."
alias ...="cd ../.."
alias gs="git status"
alias glog="git log --oneline --graph --decorate -20"

Startup time with this setup: under 50ms on a modern machine. Compare that to a fully-loaded Oh My Zsh config at 400ms+.

What About zinit?

If you want a plugin manager rather than manual git clones, zinit is the current recommendation. It handles lazy-loading (plugins only load when you actually use them) and parallel downloads.

bash -c "$(curl --fail --show-error --silent --location \
  https://raw.githubusercontent.com/zdharma-continuum/zinit/HEAD/scripts/install.sh)"

Then in your .zshrc, replace the manual source lines with:

zinit light zsh-users/zsh-autosuggestions
zinit light zdharma-continuum/fast-syntax-highlighting
zinit light ajeetdsouza/zoxide

zinit also handles deferred loading so your shell feels instant even with more plugins. It’s worth it if you’re adding more than 3-4 plugins.

Fish: “I Just Want It to Work”

Fish shell deserves an honest mention here. If you’re starting fresh and don’t have a pile of existing bash scripts, Fish is genuinely excellent.

Autosuggestions and syntax highlighting are built in. No plugins needed. The config is friendlier (~/.config/fish/config.fish). The tab completion is smarter. It just works.

The trade-off: Fish is not POSIX-compatible. Scripts written for bash won’t run in Fish without modification. If you spend any time writing shell scripts — or running scripts from the internet — you’ll hit this wall regularly. Most people keep bash as their scripting language and set Fish as their interactive shell, which works fine but adds a layer of “wait, which shell am I in?”

If your terminal is purely interactive and you rarely write scripts: Fish. If you write scripts regularly or work with servers that only have bash: stick with zsh.

Nushell: The Interesting Third Option

Nushell treats everything as structured data. ls | where size > 1mb | sort-by modified works the way you wish pipelines had always worked. It’s genuinely fascinating for data wrangling.

It’s also not replacing bash for most people yet. The syntax is different enough that you’ll be reaching for the docs constantly at first. Worth playing with in a Docker container. Not worth migrating your daily driver to unless you’re specifically doing a lot of data pipeline work in the terminal.

Migration Strategy: Don’t Blow It Up

If you’re running Oh My Zsh now:

Keep your current .zshrc working. Don’t touch it.
Create a ~/.zshrc.new and build the new setup there.
Test with zsh --rcs ~/.zshrc.new before switching.
Once you’re happy, rename files and migrate your aliases and environment variables.

The plugins and Starship work alongside each other incrementally. You don’t have to choose between “keep Oh My Zsh” and “start over” — you can run Starship as your prompt inside Oh My Zsh while you gradually add the other pieces.

Your 2 AM debugging session self will appreciate not having to reconfigure a broken shell at the worst possible moment.

The Short Version

You don’t need to switch shells to have a great terminal. Starship + zsh-autosuggestions + fast-syntax-highlighting + zoxide turns your existing bash or zsh into something you’ll actually enjoy using, with sub-50ms startup times and features that make you faster every day.

Switch to Fish if you want zero configuration and don’t write scripts. Check out Nushell when you’re curious and have an afternoon to play. But honestly? The zsh setup above covers 95% of what makes a terminal feel good, and you can be up and running in about 10 minutes.