Fish 4.0: The Fish of Theseus

Original Article ↗ Hacker News Discussion ↗

Fish shell’s upcoming 4.0 release, a near-complete rewrite from C++ to Rust, is being praised as a major engineering achievement that improves maintainability, safety, and cross-platform behavior while largely preserving performance and user experience. Commenters highlight fish’s strengths as an interactive shell—smart autosuggestions, powerful completions, minimal configuration—while repeatedly weighing them against drawbacks like non‑POSIX syntax, reduced Cygwin support due to Rust’s target coverage, and friction when pasting bash-oriented snippets. Packaging and build tooling (Cargo, CMake, feature vs. version detection) also feature prominently, with maintainers emphasizing the care taken to keep distro packagers and existing users on board.

Overall reception

  • Many commenters are enthusiastic long‑time fish users; several report switching from bash/zsh and never looking back.
  • Common theme: “just works out of the box” with minimal config, compared to zsh+plugin stacks.
  • Some are impressed the full Rust port was completed in ~2 years and consider that fast for 50k+ LOC.

Fish vs. bash/zsh and other shells

  • Pros of fish:
    • Strong interactive UX: autosuggestions, syntax highlighting, rich completions, history search, multiline editing, good built‑ins (string, math, argparse), Docker/Git‑aware completions.
    • Beginner‑friendly and low‑config; web-based config and simple function/prompt model.
    • Some see advantages from being a clean non‑POSIX design (avoids legacy shell oddities and vulnerabilities).
  • Cons / reasons to stay with bash/zsh:
    • Non‑POSIX syntax: can’t directly source .bashrc, bash snippets sometimes break; here‑docs/<<< missing; set -e semantics absent.
    • Fish scripting seen as mainly for extending fish; for “serious” scripts many prefer bash or another language.
    • Several use fish interactively but keep scripts in bash via shebangs.
    • Some prefer zsh’s flexibility and larger completion/plugin ecosystem.

Rust rewrite, portability, and tooling

  • Rust seen as improving maintainability, safety, and cross‑compilation experience (especially with custom feature‑detection crate).
  • Port did not ship a C++/Rust hybrid; transitional bindings were kept off releases to avoid distro pain.
  • Loss of Cygwin support due to missing Rust target is widely noted; some find it “sad” given reliance on Cygwin in corporate Windows environments.
  • Debate over portability:
    • One side: C++ (via GCC) clearly supports more obscure platforms.
    • Other side: Rust offers better tooling (rustup, cross‑platform crates) and higher ROI for mainstream targets.

Build, packaging, and Cargo limitations

  • Fish still uses CMake for installation because Cargo’s install model is binary‑centric and weak on data/docs layout.
  • Discussion around whether Cargo should grow richer install hooks vs. delegating that to higher‑level tools.
  • Distro packagers report it’s workable when upstream cooperates; fish maintainers say they design with packager requirements in mind.

Language behavior & configuration probing

  • Discussion of feature detection vs version detection; several argue feature detection is better but traditional autoconf‑style probing is fragile.
  • Rust’s cfg! vs #[cfg] trade‑offs are discussed in terms of catching misconfigurations across build variants.

Miscellaneous

  • Some worry about LOC increase (56k C++ → 75k Rust); maintainers attribute most of this to rustfmt’s more vertical style, not more “significant” code.