Need help with vim-fsharp?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

127 Stars 36 Forks MIT License 209 Commits 21 Opened issues


F# bindings for vim

Services available


Need anything else?

Contributors list

F# support for Vim (vim-fsharp)

Syntax and indent files have been copied from fsharp-vim with kind permissions from kongo2002.

Requires vim 7.3 or higher compiled with python 2 or 3 support.

This was adapted from The current aim is to provide a good experience for fsx scripting. On opening an fs or fsi file any project file found in the same directory will be parsed. Multiple projects are supported.


vim-fsharp requires mono and fsharp installed.

OSX and linux

Installing with pathogen
  1. Install pathogen and syntastic

  2. Clone vim-fsharp into your bundle directory.

  3. Run make inside the vim directory. This downloads the auto completion server.

Installing with vim-plug
Plug 'fsharp/vim-fsharp', {
      \ 'for': 'fsharp',
      \ 'do':  'make fsautocomplete',
Installing with NeoBundle

By VimL way: ~~~.vim NeoBundle 'fsharp/vim-fsharp', { \ 'description': 'F# support for Vim', \ 'lazy': 1, \ 'autoload': {'filetypes': 'fsharp'}, \ 'build': { \ 'unix': 'make fsautocomplete', \ }, \ 'build_commands': ['curl', 'make', 'mozroots', 'touch', 'unzip'], } ~~~

By using TOML configuration: ~~~.toml [[plugins]] description = 'F# support for Vim' repository = 'fsharp/vim-fsharp' lazy = 1 filetypes = 'fsharp' build_commands = ['curl', 'make', 'mozroots', 'touch', 'unzip'] [] unix = 'make fsautocomplete' ~~~


  1. Install pathogen and syntastic

  2. Run install.cmd


vim-fsharp utilizes the syntastic plugin in order to supply interactive syntax and type checking. You may want to install that plugin in order to get all of the fsharpbindings functionality.

Moreover you benefit from additional syntastic features like optional integration in your status bar (i.e. vim-airline).

All you have to do is to install syntastic in your vim runtime path.


Opening either

files should trigger syntax highlighting and other depending runtime files as well.

Omnicomplete triggers the fsharp autocomplete process. (suggestion: install supertab)


  • :make
    Calls xbuild on the fsproj for the current file (if any).
  • :FSharpParseProject
    Reparses all the project files and dependencies (this is done automatically when opening a .fs or .fsi file).
  • :FSharpBuildProject
    Calls xbuild on the fsproj for the current file (if any). Can also take a path to the proj file to build.
  • :FSharpRunProject
    Runs the project for the current file (if any).
  • :FSharpRunTests
    is set it will build the current project and run any tests. (Currently only tested with nunit-console.exe)
  • :FSharpToggleHelptext
    toggles g:fsharpcompletionhelptext. (See below for details)
  • leader
    Echoes the type of the expression currently pointed to by the cursor.
  • leader
    Echoes the help info (type and comments) of the expression currently pointed to by the cursor.
  • leader
    go to declaration in current window.
  • leader
    Takes you back from where go to declaration was triggered. Experimental.
FSharp Interactive
  • :FsiEval
    Evaluates an fsharp expression in the fsi
  • leader
    Same as FsiEval but from a vim command line
  • :FsiEvalBuffer
    Evaluates the entire buffer in the fsi
  • :FsiReset
    Resets the current fsharp interactive
  • :FsiRead
    Outputs any lines written by the fsi but not yet output as vim messages
  • :FsiClear
    Deletes all text from the fsi output buffer but doesn't reset the fsi session.
  • :FsiShow
    Opens the fsi-out buffer in a split window.
  • Alt-Enter
    Send either the current selection or the current line to the fsharp interactive and echoes the output the first line of the output. All output will be written to the fsi-out buffer.
  • leader
    Same as Alt-Enter

On-the-fly syntax checking

Interactive syntax/type checking requires vim 7.4 or higher and syntastic

By default your F# files will be syntax/type checked on every open/save of a vim buffer as well as after 500ms of inactivity in Normal mode. In case you would prefer not to have you errors checked continuously add the following to your vimrc:

let g:fsharp_only_check_errors_on_write = 1

In case you prefer to disable the syntax checker, add the following to your vimrc:

let g:syntastic_fsharp_checkers = ['']


You can enable debug-mode in order to inspect the fsautocomplete behavior by setting the global vim variable

to a non-zero value:
let g:fsharpbinding_debug = 1

This will create two log files

in your temporary folder (i.e.

Override the default F# interactive binary

let g:fsharp_interactive_bin = '/path/to/fsi'

You can set the msbuild/xbuild path.

let g:fsharp_xbuild_path = "/path/to/xbuild/or/msbuild"

This setting needs to point to a suitable test runner (such as nunit-console.exe)

let g:fsharp_test_runner = "/path/to/test/runner"

This enables the helptext to be displayed during auto completion. Turn off if completion is too slow.

let g:fsharp_completion_helptext = 1

Show comments, in addition to type signature, when using Omni completion (default=0).

let g:fsharp_helptext_comments = 1

If you find the default bindings unsuitable then it is possible to turn them off.

let g:fsharp_map_keys = 0

It is also possible to configure them to provide a more customised experience.

Override the default prefix of

 to the keys 
let g:fsharp_map_prefix = 'cp'

Override the default mapping to send the current like to fsharp interactive

let g:fsharp_map_fsisendline = 'p'

Override the default mapping to send the current selection to fsharp interactive

let g:fsharp_map_fsisendsel = 'p'

Override the default mapping to go to declaration in the current window

let g:fsharp_map_gotodecl = 'g'

Override the default mapping to go back to where go to declaration was triggered

let g:fsharp_map_gobackfromdecl = 'b'

Override the default mapping to evaluate an fsharp expression in the fsi

let g:fsharp_map_fsiinput = 'i'

Automatically open the result of an FsiEval (fsi-out buffer) in a vsplit window

let g:fsharp_fsi_show_auto_open = 1


I get syntax highlighting but not error checking and commands like :FsiEval are not found



The "available" and "currently enabled" checkers should be listed as "syntax". If these entries are blank, then the syntax checker has not been loaded properly. One cause can be that your vim is compiled without Python support; type

:echo has('python')
:echo has('python3')

to check this.

If both of this commands return 0 and you're on Debian 8, you may need to install the package 'vim-python-jedi' instead of 'vim' to have Python support.

NB: if you in the past installed

you need to remove this from the
directory. They don't play nicely together and
is no longer developed.


Tha maintainers of this repository appointed by the F# Core Engineering Group are:

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.