简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Starship?
Starship is a cross-shell command-line prompt: the text and symbols your terminal shows before each command. It replaces the default prompt in Bash, Fish, Zsh, PowerShell, and other common shells, so you can keep one familiar prompt whether you are on macOS, Linux, or Windows.
Its three stated design goals are compatibility, speed, and customization. The prompt is written in Rust, which is meant to keep it responsive, and it is configured through a single file rather than a separate script per shell. Instead of showing only your current directory, it can display context such as the Git branch and status, the active programming language version, or how long the previous command took.
Who it is for
- Developers who switch between shells or operating systems and want consistent prompts.
- People who work in Git repositories and want branch or dirty-state information visible at a glance.
- Users who want a clean prompt by default but still want to add modules for languages and tools they use.
Trade-offs to consider
- The default prompt is intentionally minimal, so useful details may need to be enabled.
- A single shared configuration is convenient, but it cannot express every shell-specific trick.
- Installing a prompt manager adds one more tool to your setup; if you are happy with your current prompt, there is little reason to change.
A practical next step
Install Starship, open a new terminal session, and work in a Git repository for a few minutes. If the prompt shows the branch and status clearly without slowing you down, keep it. If not, edit the configuration file to disable the modules you do not need. The project's documentation is at Starship.
How do I install Starship on my shell?
Install Starship by running its install script or a package manager, then add one line to your shell's startup file so the prompt initializes each session.
Quick install (any supported shell)
- Install the binary — the official one-liner is:
curl -sS https://starship.rs/install.sh | sh(or use a package manager such as Homebrew, Scoop, apt, or your distro's repo). - Add the init line for your shell to its config file.
- Restart the shell or re-source the config.
Init line by shell
| Shell | Config file | Line to add |
|---|---|---|
| Bash | ~/.bashrc |
eval "$(starship init bash)" |
| Zsh | ~/.zshrc |
eval "$(starship init zsh)" |
| Fish | ~/.config/fish/config.fish |
`starship init fish |
| PowerShell | $PROFILE |
Invoke-Expression (&starship init powershell) |
| Elvish | ~/.config/elvish/rc.elv |
eval (starship init elvish) |
| Ion | ~/.config/ion/initrc |
eval $(starship init ion) |
| Tcsh | ~/.tcshrc |
eval \starship init tcsh`` |
| Xonsh | ~/.xonshrc |
execx($(starship init xonsh)) |
| Nu | $env.config / env file |
`mkdir ($nu.data-dir |
| Cmd | — | Not supported the same way; use Clink with the Starship Lua script |
A concrete scenario
You use Zsh on macOS with a custom theme. Install via Homebrew, add eval "$(starship init zsh)" as the last line of ~/.zshrc (after any version managers like nvm or pyenv, so they're detected), then run exec zsh. To customize, create ~/.config/starship.toml and set STARSHIP_CONFIG if you keep it elsewhere.
Decision criteria
- Package manager vs. script: prefer your OS package manager for easier updates; use the install script when you want the latest release or your distro lags.
- Order matters: place the init line after environment setup so Starship sees the right tools.
- Existing prompt frameworks: if you already use Oh My Zsh or similar, disable or remove its theme to avoid conflicts.
Next step: run starship --version to confirm the install, then starship config to open your config file. See Starship for the full shell list and configuration options.
Can Starship be used with multiple shells on the same machine?
Yes. Starship is designed to work across many shells on the same machine, so you can install it once and enable it in each shell you use. Its own description lists support for Bash, Fish, Zsh, Ion, Tcsh, Elvish, Nu, Xonsh, Cmd and PowerShell.
H3 How it works in practice
- Starship is a single prompt program. Each shell gets a small hook that calls it, so the same configuration and prompt style apply everywhere.
- It is built with "Compatibility First" in mind, meaning it aims to work on common shells across common operating systems.
- Because it is Rust-powered, it stays fast despite showing contextual information like Git status, language versions and command duration.
- Customization lives in one shared config file, so changing your prompt in Zsh also changes it in Fish or PowerShell.
H3 A concrete scenario Suppose you use Zsh in your terminal, Bash for remote servers and PowerShell on Windows. You install Starship once, add the init line to each shell's startup file, and you get the same prompt layout everywhere. Your Git branch indicator, Python version and exit-code styling stay consistent, which reduces context switching when you move between environments.
H3 Trade-offs to consider
- Shell-specific features: some shells expose capabilities others do not, so a few modules or keybindings may behave differently.
- Startup overhead: Starship is fast, but adding it to many shells means each one runs the prompt binary; this is usually negligible.
- Config conflicts: if you already have heavy custom prompts, you will need to disable them to avoid double prompts.
H3 Next step Install Starship, then add the init line to one shell first, confirm the prompt looks right, and only then enable it in your other shells. If you want to compare with an alternative, Oh My Zsh is Zsh-focused, while Starship is shell-agnostic.
How do I customize the Starship prompt to show only the information I need?
Starship is configured through a single TOML file, normally ~/.config/starship.toml, so customizing it means editing that file rather than writing shell code. The core idea: most prompt modules are on by default, and you turn off what you don't want or adjust what each one displays.
The main levers
- Disable modules you don't care about. Anything not relevant to your workflow—cloud contexts, language version modules for languages you don't use, timing—can be switched off so it never appears.
- Trim what a module shows. For modules you keep, you can usually control the symbol, format string, and which details appear (for example, showing only the current directory name instead of the full path).
- Reorder and restructure. The overall prompt layout is itself a format string, so you can move segments, add line breaks, or put things on a second line.
- Set per-module conditions. Many modules accept a
disabledflag or awhen-style condition, letting you hide something only in certain contexts. - Theme shortcuts. Instead of configuring everything by hand, you can apply a preset theme and then adjust from there—useful if you want a fast starting point.
A practical approach
Start by observing your prompt during a normal working day and noting which segments you never read. Disable those first; that alone usually gets you most of the way. Then, for the segments that remain, shorten formats so each one earns its space. Keep the config in version control so you can experiment and roll back.
If you'd rather learn from ready-made configurations than build from scratch, the project's own documentation at Starship is the authoritative reference for module names and format options, and browsing shared dotfiles is a good way to see how others balance information density.
Does Starship work on Windows, macOS, and Linux?
Yes. Starship is designed for cross-platform use: its own compatibility statement says it works on the most common shells across the most common operating systems, so Windows, macOS, and Linux are all covered. It also supports many shells, including Bash, Zsh, Fish, PowerShell, Cmd, and others, so you are not locked into one environment.
That matters most if you move between machines. A developer who uses PowerShell on a Windows work laptop, Zsh on a personal Mac, and Bash on a Linux server can keep a similar prompt layout everywhere instead of rebuilding it per platform. The trade-off is that some prompt modules depend on tools that may not be installed or behave identically on every OS, so a configuration that looks complete on Linux may show missing segments on Windows until those tools are available.
A practical next step: install Starship on one machine, confirm the prompt appears in your shell, then copy the same config file to a second OS and check which segments load. Keep platform-specific tweaks minimal so the shared config stays portable.
How does Starship compare to other shell prompts in speed and resource usage?
Starship's core speed claim rests on being written in Rust and rendering the prompt as a single compiled binary rather than a script. That matters because most traditional prompts are shell scripts or sourced functions: every time you press Enter, your shell re-interprets that code. Starship is invoked as an external process, does its work in compiled code, and exits. The practical result is prompt latency that stays roughly flat as your configuration grows, instead of degrading the way a long, source-heavy .bashrc prompt often does.
Starship states compatibility with Bash, Fish, Zsh, Ion, Tcsh, Elvish, Nu, Xonsh, Cmd, and PowerShell across common operating systems, which is the more unusual part of its pitch. Speed comparisons between prompts are usually really comparisons between shells, so a prompt you can carry across all of them removes a variable.
Where the trade-off actually sits
- A pure shell prompt (a hand-written
PS1, or a minimal Zsh setup) can be faster in absolute terms because it never spawns a process. The gap is small in human terms, but it exists. - A script-based prompt that runs
git status, version managers, and command-duration timers on every keystroke is where Starship's compiled approach tends to win, since the expensive work is the same but the orchestration around it is cheaper. - Starship's own cost grows with what you enable. Git status in a huge monorepo, Node or Python version detection, and cloud-context modules each add work. Disabling modules you don't need is the main lever you have.
A concrete scenario
You keep one dotfiles repo and work on a laptop, a work VM, and a remote box where you switch between Bash and Zsh. With a script-based prompt you maintain three variants and debug them separately. With Starship you install one binary per machine and share one TOML config. The resource cost is a few milliseconds per prompt and a small resident binary; the saving is configuration drift you no longer have to chase.
How to decide
If your current prompt is already a short, single-line PS1 with no external commands, you are unlikely to notice a speed difference and should switch only for the cross-shell consistency. If your prompt shells out to Git, language version managers, or several status scripts, measure first: time your prompt with time around a shell startup or use your shell's built-in timing, then compare after installing Starship with a similar module set. Judge on perceived lag when you press Enter in your largest repository, not on a synthetic benchmark.
Cloudflare
Netlify
Fastmail
User reviews (0)