Define an alias in fish shell

I would like to define some aliases in fish. Apparently it should be possible to define them in

~/.config/fish/functions

but they don't get auto loaded when I restart the shell. Any ideas?

Just use alias. Here's a basic example:

# Define alias in shell
alias rmi "rm -i"

# Define alias in config file ( `~/.config/fish/config.fish` )
alias rmi="rm -i"

# This is equivalent to entering the following function:
function rmi
    rm -i $argv
end

# Then, to save it across terminal sessions:
funcsave rmi

This last command creates the file ~/.config/fish/functions/rmi.fish.

Interested people might like to find out more about fish aliases in the official manual.

This is how I define a new function foo, run it, and save it persistently.

sthorne@pearl~> function foo
                    echo 'foo was here'
                end
sthorne@pearl~> foo
foo was here
sthorne@pearl~> funcsave foo

For posterity, fish aliases are just functions:

$ alias foo="echo bar"
$ type foo
foo is a function with definition
function foo
	echo bar $argv; 
end

To remove it

$ unalias foo
/usr/bin/unalias: line 2: unalias: foo: not found
$ functions -e foo
$ type foo
type: Could not find “foo”

fish starts by executing commands in ~/.config/fish/config.fish. You can create it if it does not exist: > vim ~/.config/fish/config.fish

and save it with :wq

step1. make configuration file (like .bashrc)

> config.fish

step2. just write your alias like this; > alias rm="rm -i"

If you add an abbr instead of an alias you'll get better auto-complete. In fish abbr more closely matches the behavior of a bash alias.

abbr -a gco "git checkout"

Will -add a new abbreviation gco that expands to git checkout.

Here's a video demo of the resulting auto-complete features

Save your files as ~/.config/fish/functions/{some_function_name}.fish and they should get autoloaded when you start fish.

1. if there is not config.fish in ~/.config/fish/, make it.
2. there you can write your function .function name; command; end

To properly load functions from ~/.config/fish/functions

You may set only ONE function inside file and name file the same as function name + add .fish extension.

This way changing file contents reload functions in opened terminals (note some delay may occur ~1-5s)

That way if you edit either by commandline

function name; function_content; end

then

funcsave name

you have user defined functions in console and custom made in the same order.

@bozhidar-batsov gave an absolutely complete answer that helps one understand the inner workings of the alias/function in fish. Reading fish documentation for an alias, there is also a -s flag that is really convenient to use, but I didn't see anyone mention it.

> -s or --save Automatically save the function created by the alias into your fish configuration directory using funcsave.

One-line solution for defining and saving an alias (for example): alias cl 'clear' -s. Instantly works across all sessions and is persisted.

Navigate to the ~/.config/fish/functions/ and you'll see cl.fish file.

# Defined via `source`
function cl --wraps=clear --description 'alias cl clear'
  clear $argv;
end

make a function in ~/.config/fish/functions called mkalias.fish and put this in

function mkalias --argument key value
  echo alias $key=$value
  alias $key=$value
  funcsave $key
end

and this will create aliases automatically.

I know there are 11 answers already at this point, and they all work, but most are also suboptimal in 2022 (and for the past few years).

Short, updated, current answer for all releases since 3.0b1:

• The quickest and best way to do what is requested in this question is:

  alias -s <aliasname> "command(s)" # Or --save
  

  Important: Simply do this one time per alias at the command-line. Do not add it to your startup config.

• To list existing aliases which have been defined this way (since fish 2.5b1):

  alias
  

• To edit an alias created this way:

  funced -s <aliasname> # or --save
  

• To remove an alias defined this way (since fish 3.4.0):

  functions -e <aliasname> # or --erase
  funcsave <aliasname>
  

  Note that since 3.4.0 was only released a few weeks ago, I'll include the commands that work in previous versions as well:

  functions -e <aliasname> # or --erase
  rm ~/.config/fish/functions/<aliasname>.fish
  

  Ironically, you may even want to alias this into unalias. You'll need to first alias -s unalias the functions -e ... part, then funced -s unalias again to add the rm ....

---

Note that @nemanja's answer does include the alias -s command, but doesn't go into much detail. Regardless, since it predates mine, I wouldn't mind at all if it was the accepted answer. However, the currently accepted answer is a bit outdated. While it could, in theory, be edited, the necessary changes, IMHO, would create a different answer, which we aren't supposed to do.

While @nemanja's answer is the best solution for current fish releases, I'm writing this as a separate answer to:

• Go into more detail on why ('alias -s`) is the best solution.
• Go into more detail on why the other answers are suboptimal with current fish releases.
• Provide the additional information on editing and removing aliases which are defined this way.

---

Much more detail on why the above is preferred over the other answers

First, it is important to understand that, as Glenn Jackman (a former fish shell contributor) mentioned in this answer, the alias command in fish is just syntactic sugar for creating a function.

However, when you define an alias this way, it is defined only in memory. It is not persisted. That ability was added shortly after that answer was written.

Outdated method #1

With that in mind, the currently accepted answer from 2010 has a few issues nowadays.

First, you really shouldn't define your aliases in your config. That may have been correct in 2010, but even then I think fish supported lazy-loading of functions/aliases, which is a better option. Defining functions/aliases in your startup config is the "bash/zsh way". Fish is better than that ...

One of the (many) features that sets fish apart from bash and zsh is lazy-loading. Lazy is good in this case. You want lazy-loading. You need lazy-loading (ok, well maybe not need), but anyway ...

As the original question mentioned, it is possible to define your functions in ~/.config/fish/functions/, although it is a directory rather than a file. Note that this will be $XDG_CONFIG_HOME/fish/functions if that variable is defined.

Functions in this directory are lazy-loaded.

Lazy loading means:

• Fish does not load any part of your alias/function when it starts. This can speed up launch times significantly, especially if you have many aliases and/or complex functions, or perhaps are running on a slower system/VM/shared CPU host.

• No part of the function other than the name (for lookup purposes) is loaded into memory until it is used.

• The first time you call a function with functionname, then and only then will fish lazy-load the function from ~/.config/fish/functions/<functionname.fish>.

How much of a difference this will make will depend on a lot of factors, but personally, I keep a lookout for simple ways to optimize my configuration. One of the main factors that drove me from Zsh to fish was the increasingly slow startup of my Zsh config as I added features, functions, etc. We've made the switch to a better shell (in our opinion, I assume) -- Why not take advantage of its improved features?

This lazy-loading might sound complicated, but it's almost exactly what the alias -s command does for us without any additional effort.

In addition, the alias command, goes several steps further and automatically adds a --wraps <original_command> argument to your function so that you get the added benefit of completions. It also adds a --description, which is used to describe the function as an "alias". As a result, running just:

alias

... by itself will give you a list of all functions/aliases defined this way.

Other answers

Three separate answers also all mention using ~/.config.fish/config.fish, either with function declarations or alias commands.

As with the original answer, this is the suboptimal, bash/zsh way of doing things. This means that your aliases/functions will be processed and loaded every time you start a new shell.

I recommend that you take advantage of lazy-loading instead.

mkalias function

This answer by @Mike defines a mkalias function that creates and saves the alias. A very good solution at the time (and IMHO should have had more upvotes), but it predated fish release 3.0 which added alias --save/-s, which now does the same thing.

abbr command

@TobiasMühl's answer recommends using the abbr command, which is a reasonable alternative. However, note that alias does handle completions, and in pretty much the same manner as the abbr example given in that answer.

alias -s gco "git checkout"

And completions will be based on git checkout, just as if it were an expanded abbreviation.

There may be some cases where the completions will be more accurate because abbreviations are expanded as soon as the Space is pressed after typing the abbreviation name.

That's one of the fundamental differences between abbreviations and aliases in fish. Abbreviations are expanded at the prompt; aliases are not.

Another difference is that abbreviations are stored in variables, which are processed/loaded at shell startup (whether universal or global/config). As mentioned above, aliases are lazy-loaded.

And yet another difference is that aliases, since they are functions, can be much more complex. For instance, I have my ls set to be exa with the output piped to bat. It's just not possible define that in an abbreviation.

That said, again, abbreviations are a feature to consider using in fish. I do plan to shift a few of my aliases to abbreviations, since I have some where I want to change the arguments after expansion; something that's not possible with the unexpanded aliases.

I found the prior answers and comments to be needlessly incomplete and/or confusing. The minimum that I needed to do was:

1. Create ~/.config/fish/config.fish. This file can optionally be a softlink.
2. Add to it the line alias myalias echo foo bar.
3. Restart fish. To confirm the definition, try type myalias. Try the alias.