🔁Bash to Fish (and back)

13 Oct 2026

Fish is not POSIX compatible. Bash snippets from the internet often fail in fish. Use these rules to translate them. See Fish shell for setup.

Quick option: run it in Bash

No need to translate a one-off command:

bash -c 'some bash command'

Task	Bash	Fish
Set a variable	`FOO=bar`	`set foo bar`
Export a variable	`export FOO=bar`	`set -gx FOO bar`
Unset a variable	`unset FOO`	`set -e FOO`
Env for one command	`FOO=bar cmd`	`env FOO=bar cmd`
Command substitution	`$(cmd)`	`(cmd)` (also `$(cmd)` in fish 3.4+)
Last exit code	`$?`	`$status`
All arguments	`$@`	`$argv`
First argument	`$1`	`$argv[1]`
Chain on success	`a && b`	`a; and b` (`a && b` works in 3.0+)
Chain on failure	`a \|\| b`	`a; or b` (`a \|\| b` works in 3.0+)
Negate	`! cmd`	`not cmd` (`! cmd` works too)
Redirect both	`cmd &> file`	`cmd &> file` or `cmd > file 2>&1`
Process substitution	`<(cmd)`	`(cmd \| psub)`
Source a file	`source file`	`source file` (only for fish code)
Alias	`alias gs='git status'`	`abbr -a gs git status`
Run last command	`!!`	no `!!`, press `↑` or use `abbr`
Home directory	`~`	`~` (same)

Variables have no =. Use set name value.
Scope flags matter. -l local, -g global, -x export, -U universal (saved across sessions).
Lists are native. set fruits apple pear makes a list. Read with $fruits[1]. Fish counts from 1, not 0.
$PATH is a list. Use fish_add_path /some/dir and not export PATH=....
No word splitting. $var is never split on spaces, so quotes are rarely needed around variables.
No export keyword. Use set -gx.
Blocks end with end. No then, fi, do, done or esac.
No heredocs. Use printf or echo with \n, or pipe from string.
No $((...)) maths. Use math 1 + 2.
No ${var:-default} or ${var%suffix}. Use string replace, string match, string sub, or set -q.
No ${var}. Write $var. To join text right after it, write {$var}text.
Globs that match nothing are an error in fish, not passed through.
Quotes: single quotes are literal. Double quotes expand variables but not $(...) before fish 3.4.

If / else:

# bash
if [ -f file ]; then
  echo yes
else
  echo no
fi

# fish
if test -f file
    echo yes
else
    echo no
end

For loop:

# bash
for f in *.md; do
  echo "$f"
done

# fish
for f in *.md
    echo $f
end

While loop:

# bash
while read -r line; do
  echo "$line"
done < file

# fish
while read -l line
    echo $line
end < file

Function:

# bash
greet() {
  echo "hi $1"
}

# fish
function greet
    echo "hi $argv[1]"
end

Case:

# bash
case "$x" in
  a) echo A ;;
  *) echo other ;;
esac

# fish
switch $x
    case a
        echo A
    case '*'
        echo other
end

Check a variable is set:

# bash
[ -n "$FOO" ]

# fish
set -q FOO
test -n "$FOO"

String work:

string replace foo bar $str
string match -r '^v(\d+)' $str
string split , $str
string join , $list
string upper $str

Add = and drop set. set foo bar becomes foo=bar. No spaces around =.
Lists become arrays. set l a b c becomes l=(a b c). Read with ${l[0]} (Bash counts from 0) or "${l[@]}" for all.
Quote variables. Bash splits unquoted variables on spaces. Write "$var".
Close blocks the Bash way. end becomes fi, done or esac. Add then after if and do after for or while.
test becomes [ ] or [[ ]]. test -f x becomes [ -f x ].
string has no Bash twin. Use parameter expansion (${var//foo/bar}), sed, tr or cut.
switch / case become case ... esac with ;; after each branch and *) as the default.
function name becomes name() { ...; }.
$status after a pipe becomes ${PIPESTATUS[@]} in Bash.
Fish has no export -f. Bash functions can be exported, fish functions cannot.

Never source a bash script in fish. It fails, or worse, half-works. Run it with bash script.sh.
For tools that write shell setup code (nvm, conda, pyenv, direnv), look for a fish option or a fish plugin. Most have one.
To use a bash-only environment script, try bass (external site): bass source ~/.nvm/nvm.sh.
Write fish scripts with #!/usr/bin/env fish. Write portable scripts with #!/usr/bin/env bash.