Starship Prompt Review: The Shell Prompt I Stopped Fiddling WithDev Tools

Starship Prompt Review: The Shell Prompt I Stopped Fiddling With

by Joule P. Kraft · November 20, 2026

As an Amazon Associate, and through other affiliate programs (including SONOFF), I earn from qualifying purchases. No affiliate relationship influences my recommendations.

I have rewritten my shell prompt more times than I have rewritten my resume. Hand rolled PS1 strings, Powerlevel10k, a dozen Oh My Zsh themes, a fish prompt function I was weirdly proud of. Each one lasted until I switched shells, set up a new laptop, or noticed the prompt took a visible beat to draw in a large repo.

Starship is the one that ended the cycle. It has been my prompt on every machine for well over a year, across zsh at work, fish at home, and the occasional Nushell experiment, with the same config file synced through my dotfiles. Version 1.27.0 landed in October, and nothing about it has made me want to touch the setup again. That is the best thing I can say about a prompt.

This review covers what Starship actually is, the trimmed config I run, how it compares on speed with the frameworks it replaced, and the places where it still annoys me. If you are coming from a heavy zsh setup, read why I quit Oh My Zsh first. Starship was half of that move.

What Starship is

Starship is a prompt, nothing else. It is a single Rust binary that your shell calls each time it needs to draw the prompt. Starship looks at the current directory and environment, figures out what is relevant, and prints the prompt. Your shell displays it.

That design is why it works everywhere. The shell integration is one line, and all the logic lives in the binary and one config file at ~/.config/starship.toml. The same file produces the same prompt in:

  • zsh
  • fish
  • bash
  • Nushell
  • PowerShell, Elvish, Ion, xonsh, and a few others I have never used

The core idea is modules. There is a module for the directory, one for git branch and status, one each for dozens of languages and runtimes (Node, Python, Rust, Go, Ruby, Java), one for cloud contexts (AWS, Kubernetes, gcloud), one for command duration, one for battery, and many more. Most modules only appear when they apply. The Node version shows up when there is a package.json nearby and vanishes when you cd out. That is what keeps a Starship prompt short in practice even though the full module list is enormous.

Install and first run

On macOS:

brew install starship

On Linux, your package manager probably has it, or use the official install script from the Starship site. Then add one line to the end of your shell config:

# ~/.zshrc
eval "$(starship init zsh)"
# ~/.config/fish/config.fish
starship init fish | source

Open a new terminal and you have the default prompt. It will look busy. Many symbols assume a Nerd Font, so if you see empty boxes, install one and set it in your terminal. If you are picking a terminal at the same time, my best terminal emulators roundup and Ghostty review cover font rendering.

If you want a quick starting look instead of building from scratch, presets do it in one command:

starship preset plain-text-symbols -o ~/.config/starship.toml

plain-text-symbols is the one I recommend for servers and fresh machines, because it needs no special font. The nerd-font-symbols, tokyo-night, and pastel-powerline presets are the popular pretty options.

The config I actually kept

My first month with Starship was a config rabbit hole. My config a year later is short. Here is nearly all of it:

# ~/.config/starship.toml
add_newline = false
command_timeout = 500

format = """
$directory\
$git_branch\
$git_status\
$python\
$nodejs\
$rust\
$kubernetes\
$cmd_duration\
$line_break\
$character"""

[directory]
truncation_length = 3
truncate_to_repo = true

[git_status]
ahead = "⇡${count}"
behind = "⇣${count}"
diverged = "⇕"

[cmd_duration]
min_time = 3_000

[kubernetes]
disabled = false

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

The decisions that matter:

  • An explicit format string. By default Starship includes every module that applies. Listing only the modules I actually read removed half the noise, and it means a new release can not add something to my prompt without my say so.
  • Directory truncated to the repo root. Inside a project I see jpk.io/src/content instead of the full home path. Outside a repo it keeps the last three segments.
  • Command duration only above three seconds. I want to know when a build or test run was slow. I do not want took 42ms on every ls.
  • Kubernetes context on. It is disabled by default. I turned it on after the one time I ran a command against the wrong cluster. A visible context name is cheap insurance.
  • Two line layout. The prompt character sits on its own line, so long paths and branch names never squeeze the space I type in.

The command_timeout bump is the one setting I would tell everyone to check. If a module takes longer than the timeout, Starship skips it and prints a warning. On a slow network filesystem or a big repo, the default can cause warnings and a missing git segment.

Speed: does it actually feel fast?

Starship’s pitch is that it is fast, and in daily use it is. The prompt draws instantly in normal repos. The binary starts quickly, and modules are evaluated in parallel.

You do not have to trust my feelings. Starship ships its own profiler:

starship timings

Run that inside a repo and it lists how long each module took to render. In my work repo the only module that ever shows up as meaningful is git_status, which makes sense: it has to ask git about the working tree. Everything else is a rounding error.

Compared with what I used before:

  • Oh My Zsh with a git heavy theme had a noticeable delay in large repos and added startup time for the framework itself. Starship dropped both.
  • Powerlevel10k is honestly just as fast, maybe faster, thanks to its instant prompt trick. But it is zsh only, and its maintainer has said it is on limited support. Starship’s advantage is portability and an active project, not raw speed.
  • A hand rolled fish prompt was fast but I had to maintain it, and I did not want to port it to zsh for work.

If you work in a genuinely huge monorepo, git_status can still lag. The fix is to disable the expensive parts of that module, or turn on git’s own filesystem monitor and untracked cache so every tool benefits, not only your prompt.

The features I did not expect to use

A few things beyond the obvious earned a place in my workflow:

  • starship explain prints what each segment of the current prompt means and how long it took. Handy when a teammate asks what the odd symbol after the branch name is.
  • Environment variable module. I show a short marker when AWS_PROFILE points at production. Bright red, impossible to miss.
  • Language versions only when relevant. Seeing the Python version appear the moment I enter a project caught a wrong interpreter more than once. It pairs well with mise and uv, because the prompt shows the version those tools actually activated.
  • Per shell differences when I want them. The shell module (off by default) prints which shell I am in, which I enable only on the machine where I bounce between fish and Nushell.

Where Starship falls short

It is not perfect, and a few complaints come up again and again:

  • Too much by default. The out of the box prompt shows a lot. New users read this as clutter and bounce. The fix is an explicit format string, but you have to know to do it.
  • The docs are a wall. Every module is documented, which is great, but there are a lot of them, and finding the one option you want means scrolling a very long page.
  • Font assumptions. Many presets and screenshots assume a Nerd Font. On a fresh server or a colleague’s laptop you get boxes. I keep the plain text symbols preset for SSH machines.
  • Not a full framework. Starship does the prompt and stops there. If you relied on Oh My Zsh for completions, aliases, and plugins, you will need replacements. I use zoxide for navigation, Atuin for history, and a small set of my own aliases.
  • Async rendering is not its trick. Unlike Powerlevel10k’s instant prompt, Starship waits for modules, within your timeout, before drawing. Usually you will never notice. In a pathological repo you might.

Who should use it

Use Starship if you use more than one shell, switch machines often, want a prompt config that lives in one small dotfile, or are leaving a heavy zsh framework and want a fast, maintained replacement.

Skip it if you are a zsh only user already happy on Powerlevel10k and it is fast for you, or if you genuinely want a bare $ prompt. A minimal PS1 costs nothing.

The Bottom Line

Starship is the rare dev tool that got less interesting the longer I used it, and I mean that as a compliment. The first week was spent tweaking. Every week since, it has just drawn a short, accurate prompt in whatever shell I opened, on whatever machine I was using, from one file in my dotfiles.

Install it, start from the plain text symbols preset, write an explicit format with only the modules you read, and check starship timings once in your biggest repo. Then stop touching it. 4.5 out of 5, losing half a point only for defaults that show too much and documentation that could use a better map.