windsurf.vim is a free, open source ides & code editors project written in Vim Script and released under MIT. It has 5,141 GitHub stars, 195 forks and 135 open issues, and was last pushed 6 months ago. On this registry it ranks #21 of 28 tracked projects in IDEs & Code Editors, with 5 head-to-head comparisons available.

What is windsurf.vim?

windsurf.vim is the free, MIT-licensed Vim Script plugin that brings Windsurf's AI code completion into Vim and Neovim, and it is aimed at developers who want Copilot-style suggestions inside their terminal editor rather than in a separate IDE.

What it is

windsurf.vim is the Vim and Neovim implementation of the Windsurf plugin, published under the Exafunction organisation and distributed from the repository Exafunction/windsurf.vim. The project describes Windsurf as autocompleting your code with AI in all major IDEs, and states that this particular implementation was launched to bring that capability to Vim and Neovim users specifically. It belongs to the Developer Tools / IDEs & Code Editors category, is written in Vim Script and licensed MIT, and at the time of writing carries 5,141 stars, 195 forks and 135 open issues, with the most recent push on 31 March 2026.

The problem it addresses is narrow but concrete. Developers who write in Vim or Neovim and want inline AI completion have historically had to either leave their editor or bolt on a plugin built for a different ecosystem. windsurf.vim lives in the Vim plugin ecosystem and installs like any other plugin, while presenting itself as an alternative to GitHub Copilot rather than as a general-purpose editor extension. It replaces the Copilot-style completion workflow with one driven by the codeium# family of functions, so the accept, cycle and dismiss actions are bound to keys in the user's own configuration rather than to a fixed editor UI.

Key capabilities

  • Inline AI autocompletion for Vim and Neovim, described by the project as a free, ultrafast alternative to Copilot.
  • Suggestion control through named functions: codeium#Accept(), codeium#Clear(), codeium#CycleCompletions(1) and codeium#CycleCompletions(-1), plus codeium#Complete() to trigger a suggestion manually.
  • Partial acceptance with codeium#AcceptNextWord() and codeium#AcceptNextLine(), which take only the next word or line of a suggestion.
  • Rebindable keys, with defaults switched off through g:codeium_disable_bindings = 1 in Vim or vim.g.codeium_disable_bindings = 1 in Neovim, and the Tab binding alone disabled by g:codeium_no_map_tab.
  • A documented command and configuration reference available in-editor through :help codeium.
  • Editor support down to Vim 9.0.0185 and Neovim 0.6.
  • Plugin-manager integration, with examples given for wbthomason/packer.nvim and folke/lazy.nvim, and language coverage reflected in the repository topics: Go, JavaScript, Python and Ruby among them.

Who uses it and how

  • Vim and Neovim users who want AI completions without moving to a full IDE or a different editor.
  • Neovim users running modern plugin-manager setups such as folke/lazy.nvim or wbthomason/packer.nvim, who define keymaps in Lua or Vimscript.
  • Developers on Vim 9.0.0185 or newer, or Neovim 0.6 or newer, since those are the minimum supported editor versions.
  • Developers working across the languages listed in the project topics, including Go, JavaScript, Python and Ruby.
  • Contributors: the README explicitly welcomes pull requests and issues, and the repository shows 195 forks and 135 open issues.

Getting started

Install Vim at version 9.0.0185 or later, or Neovim at 0.6 or later, then add Exafunction/windsurf.vim through your Vim plugin manager of choice or manually. After installation, run :Codeium Auth to set up the plugin and begin using it; :help codeium lists the available commands and options.

How it compares

The project positions itself directly against GitHub Copilot as the free alternative, and the plugin's own source is MIT-licensed, so the editor-side code can be read, forked and contributed to freely. The distinction stops at the plugin: completing code still depends on the vendor's hosted service, which is why setup begins with an authentication command and why the homepage points to codeium.com rather than to a local model. Anyone who needs completion to run entirely on their own machine, or who cannot tie editor setup to a third-party account, is outside what this repository offers.

When to use it — and when not to

This is a good fit for an individual Vim or Neovim user who wants Copilot-style completions with minimal configuration and is comfortable authenticating with the hosted Windsurf service. It is a poor fit for anyone who cannot accept a cloud-dependent completion service, or who is pinned to an older Vim or Neovim release below the stated minimums. The practical caveats are that the repository carries a sizeable open-issue backlog, and that the README excerpt is heavy on badges and defers most detail to external documentation, the :help codeium reference and a linked tutorial, so expect to do some reading outside the repository before it is fully configured.

project readme (upstream, from github) — read inline


Discord Twitter Follow License Docs Canny Board built with Windsurf

Visual Studio JetBrains Open VSX Google Chrome

windsurf.vim

Free, ultrafast Copilot alternative for Vim and Neovim

Windsurf autocompletes your code with AI in all major IDEs. We launched this implementation of the Windsurf plugin for Vim and Neovim to bring this modern coding superpower to more developers. Check out our playground if you want to quickly try out Windsurf online.

Contributions are welcome! Feel free to submit pull requests and issues related to the plugin.


Example


🚀 Getting started

  1. Install Vim (at least 9.0.0185) or Neovim (at least 0.6)

  2. Install Exafunction/windsurf.vim using your vim plugin manager of choice, or manually. See Installation Options below.

  3. Run :Codeium Auth to set up the plugin and start using Windsurf.

You can run :help codeium for a full list of commands and configuration options, or see this guide for a quick tutorial on how to use Windsurf.

🛠️ Configuration

For a full list of configuration options you can run :help codeium. A few of the most popular options are highlighted below.

⌨️ Keybindings

Windsurf provides the following functions to control suggestions:

Action Function Default Binding
Clear current suggestion codeium#Clear() ``
Next suggestion codeium#CycleCompletions(1) ``
Previous suggestion codeium#CycleCompletions(-1) ``
Insert suggestion codeium#Accept() ``
Manually trigger suggestion codeium#Complete() ``
Accept word from suggestion codeium#AcceptNextWord() ``
Accept line from suggestion codeium#AcceptNextLine() ``

Windsurf's default keybindings can be disabled by setting

let g:codeium_disable_bindings = 1

or in Neovim:

vim.g.codeium_disable_bindings = 1

If you'd like to just disable the `` binding, you can alternatively use the g:codeium_no_map_tab option.

If you'd like to bind the actions above to different keys, this might look something like the following in Vim:

imap <script><silent><nowait><expr> <C-g> codeium#Accept()
imap <script><silent><nowait><expr> <C-h> codeium#AcceptNextWord()
imap <script><silent><nowait><expr> <C-j> codeium#AcceptNextLine()
imap <C-;>   <Cmd>call codeium#CycleCompletions(1)<CR>
imap <C-,>   <Cmd>call codeium#CycleCompletions(-1)<CR>
imap <C-x>   <Cmd>call codeium#Clear()<CR>

Or in Neovim (using wbthomason/packer.nvim or folke/lazy.nvim):

-- Remove the `use` here if you're using folke/lazy.nvim.
use {
  'Exafunction/windsurf.vim',
  config = function ()
    -- Change '<C-g>' here to any keycode you like.
    vim.keymap.set('i', '<C-g>', function () return vim.fn['codeium#Accept']() end, { expr = true, silent = true })
    vim.keymap.set('i', '<c-;>', function() return vim.fn['codeium#CycleCompletions'](1) end, { expr = true, silent = true })
    vim.keymap.set('i', '<c-,>', function() return vim.fn['codeium#CycleCompletions'](-1) end, { expr = true, silent = true })
    vim.keymap.set('i', '<c-x>', function() return vim.fn['codeium#Clear']() end, { expr = true, silent = true })
  end
}

(Make sure that you ran :Codeium Auth after installation.)

⛔ Disabling Windsurf

Windsurf can be disabled for particular filetypes by setting the g:codeium_filetypes variable in your vim config file (vimrc/init.vim):

let g:codeium_filetypes = {
    \ "bash": v:false,
    \ "typescript": v:true,
    \ }

Windsurf is enabled by default for most filetypes.

You can also disable codeium by default with the g:codeium_enabled variable, and enable it manually per buffer by running :CodeiumEnable:

let g:codeium_enabled = v:false

or in Neovim:

vim.g.codeium_enabled = false

Or you can disable codeium for all filetypes with the g:codeium_filetypes_disabled_by_default variable, and use the g:codeium_filetypes variable to selectively enable codeium for specified filetypes:

" let g:codeium_enabled = v:true
let g:codeium_filetypes_disabled_by_default = v:true

let g:codeium_filetypes = {
    \ "rust": v:true,
    \ "typescript": v:true,
    \ }

If you would like to just disable the automatic triggering of completions:

let g:codeium_manual = v:true

" You might want to use `CycleOrComplete()` instead of `CycleCompletions(1)`.
" This will make the forward cycling of suggestions also trigger the first
" suggestion manually.
imap <C-;> <Cmd>call codeium#CycleOrComplete()<CR>

To disable automatic text rendering of suggestions (the gray text that appears for a suggestion):

let g:codeium_render = v:false

Show Windsurf status in statusline

Windsurf status can be generated by calling the codeium#GetStatusString() function. In Neovim, you can use vim.api.nvim_call_function("codeium#GetStatusString", {}) instead. It produces a 3 char long string with Windsurf status:

  • '3/8' - third suggestion out of 8
  • '0' - Windsurf returned no suggestions
  • '*' - waiting for Windsurf response

In normal mode, status shows if Windsurf is enabled or disabled by showing 'ON' or 'OFF'.

In order to show it in status line add following line to your .vimrc:

set statusline+=\{…\}%3{codeium#GetStatusString()}

Shorter variant without Windsurf logo:

set statusline+=%3{codeium#GetStatusString()}

Please check :help statusline for further information about building statusline in VIM.

vim-airline supports Windsurf out-of-the-box since commit 3854429d.

Launching Windsurf Chat

Calling the codeium#Chat() function or using the Codeium Chat command will enable search and indexing in the current project and launch Codeium Chat in a new browser window.

:call codeium#Chat()
:Codeium Chat

The project root is determined by looking in Vim's current working directory for some specific files or directories to be present and goes up to parent directories until one is found. This list of hints is user-configurable and the default value is:

let g:codeium_workspace_root_hints = ['.bzr','.git','.hg','.svn','_FOSSIL_','package.json']

Note that launching chat enables telemetry.

💾 Installation Options

💤 Lazy

{
  'Exafunction/windsurf.vim',
  event = 'BufEnter'
}

🔌 vim-plug

Plug 'Exafunction/windsurf.vim', { 'branch': 'main' }

📦 Vundle

Plugin 'Exafunction/windsurf.vim'

📦 packer.nvim:

use 'Exafunction/windsurf.vim'

💪 Manual

🖥️ Vim

Run the following. On windows, you can replace ~/.vim with $HOME/vimfiles:

git clone https://github.com/Exafunction/windsurf.vim ~/.vim/pack/Exafunction/start/windsurf.vim
💻 Neovim

Run the following. On windows, you can replace ~/.config with $HOME/AppData/Local:

git clone https://github.com/Exafunction/windsurf.vim ~/.config/nvim/pack/Exafunction/start/windsurf.vim

Frequently asked questions

Is windsurf.vim free to use?

windsurf.vim is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does windsurf.vim do?

Free, ultrafast Copilot alternative for Vim and Neovim

What is windsurf.vim written in?

windsurf.vim is primarily written in Vim Script. Its source is publicly available at https://github.com/Exafunction/windsurf.vim, and it has 5,141 GitHub stars.