whetuu

whetuu (written whetū on its site) is a status line and history picker for fish, bash and zsh, written in zig and shipped as a single binary. It has no config file at all — not "sensible defaults with a config file available", but no configuration format in the program. Install is a binary on PATH plus one line in your shell config, and the shell hook drives everything from there, so the two commands that matter (render and history add) are called for you and never typed by hand.

What the status line shows

Segments appear left to right and only when relevant. user@host shows in bold green over SSH, and in bold red when you are root, which is the warning rather than the label. The directory collapses $HOME to ~ and keeps the anchor plus as many trailing directories as fit the terminal width. Git contributes three segments: the branch (or (detached)) in magenta, any operation underway in yellow — (rebasing 2/7), (merging), (cherry-picking) — and a bracketed group covering conflicts, stashes, staged, modified, untracked, ahead and behind. The language segment shows a logo and toolchain version in the brand colour for 39 languages and tools, detected from a project manifest, a source file extension, or an infra marker. A timer appears when the previous command ran two seconds or longer. The prompt character is a star, purple by default or in the language's brand colour, turning red after a failed command.

Nerd Font glyphs carry the branch marker, the language logos and the star, so a terminal without a Nerd Font shows empty boxes.

The history picker

The up arrow opens a picker instead of stepping back one command. Commands are recorded after they finish and only when they exited cleanly and are text, so typos and an image pasted into the terminal never enter the store. Each command is saved with the directory it ran in, and the picker opens scoped to the current directory, falling back to all history when that directory has none.

The one command that is shown but never stored is the one that just failed. It sits at the top of the list in red until you run something else, so the flow after a broken command is up-arrow, pick it, fix it.

Rows are syntax highlighted, with command name, flags, paths, variables, quoted strings and operators each taking a colour from your terminal theme — the same instinct as delta applying highlighting to git's output rather than inventing a palette. A row too wide for the window loses its middle to … rather than its tail, which keeps a run of commands sharing a long prefix distinguishable.

Keys are short: type to filter (every word must match, case-insensitive), ↑/↓ to move, Home/End for newest and oldest, Ctrl+G to toggle between this directory's history and all of it, Tab to copy the selection into the search field for editing, Enter to run, Esc to cancel leaving whatever you typed on the command line.

Why it is fast

A status line runs before every prompt, so its cost is paid constantly. whetuu renders in about 2 ms. The slowest module runs as a task via std.Io while the others run alongside it, so a render costs about as much as its slowest probe rather than the sum of all of them. The published measurement is hyperfine --warmup 40 --runs 400 on a 13th-gen i9-13900H, ReleaseFast, pinned to performance cores on an idle machine; in the author's monorepo the whole status line costs about what git status costs on its own.

Three details do the rest of the work:

Outside a repository, neither subprocess runs. whetuu walks up from the current directory looking for .git, which is a handful of stat calls, and only starts git once it has found one. A directory with no repository and no project costs a millisecond.

Both subprocesses are bounded and concurrent: git gets 250 ms, the toolchain probe gets 200 ms, so the worst case is the larger of the two. A git that hangs for 30 seconds still returns a prompt in 257 ms, minus the git segment.

The git call passes --no-optional-locks, so git reads the index without refreshing it and never takes index.lock — which a git commit running in another terminal would otherwise fail to acquire.

The picker stays fast on large stores because the up arrow reads the most recent few megabytes rather than the whole file. It opens in about 20 ms on a 70 MB store just as it does on a 400 KB one, and nothing is deleted to keep it that way.

Security posture

The security section is unusually specific for a prompt tool, which is appropriate given that the thing sees every command you run and the picker keeps them.

There is no socket, no HTTP client, no sync, no telemetry and no update check in the binary. Two files get written: the history store, created mode 600 and reset to 600 on every write so one left readable by an older version corrects itself, and a cache of toolchain version strings at ~/.cache/whetuu/versions. Both live under XDG directories rather than next to the binary, so uninstalling the program never takes the history with it, and whetuu paths prints both locations (marking whichever does not exist yet).

No shell is ever spawned. The two subprocesses, git and the toolchain probe, both get a fixed argument list rather than a command line, so nothing you type is ever interpreted as a command; state like a rebase in progress is read straight out of .git with no subprocess at all. Every control byte in a command, branch name or directory becomes ? before it reaches the terminal, so a freshly-cloned repository cannot repaint your screen through the prompt. Having no config file means no config parser, no theme format, and nothing of yours executed at startup.

The one caveat the author names himself: the language module picks which toolchain to probe from the files in the current directory, so entering an untrusted repository can make whetuu run something like node --version. It runs whatever PATH resolves, never a binary from the repository.

Commands starting with a space are never recorded, which is the escape hatch for anything carrying a token.

Install and platforms

$ curl --proto '=https' --tlsv1.2 -fsSL https://yamafaktory.github.io/whetuu/install.sh | sh

The installer detects the platform, verifies the download, drops the binary in ~/.local/bin, and appends the init line to the config of the shell in $SHELL — that shell only, never twice, and a PATH line only if ~/.local/bin is not already on PATH. WHETUU_NO_MODIFY=1 makes it print the lines instead of writing them, and whetuu init <shell> prints them plus the file they belong in. The manual path is a tarball plus SHA256SUMS:

$ sha256sum -c SHA256SUMS --ignore-missing && tar -xzf whetuu-*.tar.gz && mv whetuu ~/.local/bin/

Releases cover macOS and Linux on x86-64 and ARM64; the Linux builds are static musl with no runtime dependencies. Uninstall is rm ~/.local/bin/whetuu && rm -rf ~/.local/share/whetuu ~/.cache/whetuu, plus deleting the # whetuu block from the shell config. No Windows builds are offered.

Status and watchlist

MIT, 35 stars, one contributor. The repository was created 2026-07-05 and the latest tag at ingest is v0.1.10 (2026-07-27), so this is a three-week-old pre-1.0 project by a single author.

Added to watchlist on that basis. The engineering is careful in the places that usually get skipped — the --no-optional-locks detail, the bounded probes, the control-byte defanging — and the no-config-file stance is a real differentiator against the configurable prompts it competes with, but it is exactly that stance that makes adoption a bet on the author's taste. Worth re-checking for a second contributor, a 1.0, whether the zero-config position survives feature requests, and whether the 39-toolchain detection list keeps up.