Godot + Vim

Intro

Godot engine has rock solid built-in editor but I still feel more comfortable within my (g)(n)vim environment.

This plugin provides:

GDScript and GSL syntax highlighing
Folding
Run commands:
- Run current scene: :GodotRunCurrent
- Run last scene: :GodotRunLast
- Select and run a scene with standard vim tab completion (default is a main scene): :GodotRun
- Select and run a scene with a FZF (if installed): :GodotRunFZF

All commands are local to buffer — available only in gdscript or gsl buffers.

For IDE-like completion I suggest to try YouCompleteMe or coc.nvim plugin. (Both do a really great job providing gdscript completion for me).

https://www.youtube.com/watch?v=ALXN4HJ5bsg

Select And Run Scene

Use :GodotRun <TAB> to select a scene and run it. :GodotRun<CR> will run main scene.
Use :GodotRunFZF<CR> to select a scene using FZF (if installed) and run it.

Note that commands assume godot executable is on your PATH, i.e. you can run godot from your terminal. If this is not the case, specify it in your settings:

For windows

" windows example
let g:godot_executable = 'C:/Path/To/Godot/godot.exe'

For OSX

" OSX example
let g:godot_executable = '/Applications/Godot.app/Contents/MacOS/Godot'

80359547 a5fc6c00 8886 11ea 9cdd bc027d46db4c

Note	To run game or a scene in "async way" install either vim-dispatch or asyncrun.vim.

Settings

No default mappings are provided.

Good practice is to put your personal filetype specific settings into after directory: ~/.vim/after/ftplugin/gdscript.vim (or ~/vimfiles/after/ftplugin/gdscript.vim if you’re on windows).

" to use folding provided by plugin
setlocal foldmethod=expr
setlocal shiftwidth=4
setlocal tabstop=4
nnoremap <buffer> <F4> :GodotRunLast<CR>
nnoremap <buffer> <F5> :GodotRun<CR>
nnoremap <buffer> <F6> :GodotRunCurrent<CR>
nnoremap <buffer> <F7> :GodotRunFZF<CR>

Or you can use autocommand in your .vimrc (example):

func! GodotSettings() abort
    setlocal foldmethod=expr
    setlocal tabstop=4
    nnoremap <buffer> <F4> :GodotRunLast<CR>
    nnoremap <buffer> <F5> :GodotRun<CR>
    nnoremap <buffer> <F6> :GodotRunCurrent<CR>
    nnoremap <buffer> <F7> :GodotRunFZF<CR>
endfunc
augroup godot | au!
    au FileType gdscript call GodotSettings()
augroup end

Installation

Using plugin manager

Follow your plugin manager documentation, for example, vim-plug does it this way:

" Specify a directory for plugins
call plug#begin('~/.vim/plugged')

Plug 'habamax/vim-godot'

" ... other plugins ...

" Initialize plugin system
call plug#end()

Manual with git

Clone this repo to your vim/nvim packages directory:

Vim on Linux or OSX

git clone https://github.com/habamax/vim-godot ~/.vim/pack/plugins/start/vim-godot

Neovim on Linux or OSX

git clone https://github.com/habamax/vim-godot ~/.config/nvim/pack/plugins/start/vim-godot

Vim on Windows

git clone https://github.com/habamax/vim-godot C:/Users/USERNAME/vimfiles/pack/plugins/start/vim-godot (1)

Neovim on Windows

git clone https://github.com/habamax/vim-godot C:/Users/USERNAME/AppData/Local/nvim/pack/plugins/start/vim-godot (1)

Change USERNAME to your user name

Manual

Download zip archive (available in Code › Download ZIP)
Unpack it to appropriate folder defined in Manual with git
Make sure that contents of the archive is in …/start/vim-godot directory:
- autoload
- ftdetect
- ftplugin
- … etc

Setting up YouCompleteMe for Godot 3.2.2+

Install and set up YCM according to it’s documentation. (i.e. install with package manager then run ./install.py).
Make sure general completion works for you.
Follow instructions for enabling godot.

Or you can just add this to your vimrc:

if !has_key( g:, 'ycm_language_server' )
  let g:ycm_language_server = []
endif

let g:ycm_language_server += [
  \   {
  \     'name': 'godot',
  \     'filetypes': [ 'gdscript' ],
  \     'project_root_files': [ 'project.godot' ],
  \     'port': 6005
  \   }
  \ ]

Note	This is not a comprehensive `YouCompleteMe` setup guide. It just works for me and hopefully would work for you.

Setting up coc.nvim for Godot 3.2.2+

Install coc.nvim, make sure it does general completion for you.

Open :CocConfig and add following lines:

{
    "languageserver": {
        "godot": {
            "host": "127.0.0.1",
            "filetypes": ["gdscript"],
            "port": 6005
        }
    }
}

Save and restart

Note	This is not a comprehensive `coc.nvim` setup guide. It just works for me and hopefully would work for you.

To find which port is correct for your version of the Godot Engine, go to Editor > Editor Settings > Network > Language Server

Setting up ale for Godot 3.2.2+

Install ale, make sure it does general completion for you and register the Godot LSP server as follows in your vimrc:

" Enable ALE auto completion globally
let g:ale_completion_enabled = 1

" Allow ALE to autoimport completion entries from LSP servers
let g:ale_completion_autoimport = 1

" Register LSP server for Godot:
call ale#linter#Define('gdscript', {
\   'name': 'godot',
\   'lsp': 'socket',
\   'address': '127.0.0.1:6008',
\   'project_root': 'project.godot',
\})

Save and restart

Note	This is not a comprehensive ALE setup guide. Make sure to adjust it to your needs.

Setting up ctags

Put the following contents:

--langdef=GDScript
--langmap=GDScript:.gd
--regex-GDScript=/^func[ \t]+([a-zA-Z0-9_]+)/\1/f,function,function definitions/
--regex-GDScript=/^(onready[ \t]+)?var[ \t]+([a-zA-Z0-9_]+)/\2/v,variable,variable definitions/
--regex-GDScript=/^(export[ \t]*(.*)?[ \t]+)?var[ \t]+([a-zA-Z0-9_]+)/\3/v,variable,variable definitions/

~/.ctags.d/gdscript.ctags if you use universal ctags or
~/.ctags if you use exuberant ctags

To use it together with tagbar, put following into your vimrc or init.vim:

let g:tagbar_type_gdscript = {
			\'ctagstype' :'gdscript',
			\'kinds':[
			\'v:variables',
			\'f:functions',
			\]
			\}

Setting up Neovim native lsp with nvim-cmp

Install the following plugins

Plug 'neovim/nvim-lspconfig'
"A good completion plugin
Plug 'hrsh7th/cmp-nvim-lsp'
Plug 'hrsh7th/cmp-buffer'
Plug 'hrsh7th/nvim-cmp'

put this in your init.vim to set up the gdscript server and connecting cmp to it (the mappings are the official cmp mappings you can remove or change them)

set completeopt=menu,menuone,noselect

lua << EOF
require'lspconfig'.gdscript.setup{capabilities = require('cmp_nvim_lsp').update_capabilities(vim.lsp.protocol.make_client_capabilities())}

local cmp = require'cmp'

cmp.setup({
  mapping = {
    ['<C-d>'] = cmp.mapping.scroll_docs(-4),
    ['<C-f>'] = cmp.mapping.scroll_docs(4),
    ['<C-Space>'] = cmp.mapping.complete(),
    ['<C-e>'] = cmp.mapping.close(),
    ['<CR>'] = cmp.mapping.confirm({ select = true }),
  },

  sources = {
    { name = 'nvim_lsp' },
    { name = 'buffer' },
  }
})
EOF

Setup vim as an external editor for Godot

Note I didn’t try it myself, but @macmv had provided some info about it.

Open menu Editor/Editor Settings/ then navigate to General/External/:

Tick Use external editor
Add vim to Exec Path
Add --servername godot --remote-send "<C-\><C-N>:n {file}<CR>{line}G{col}|" to Exec Flags

Setup Neovim as an external editor for Godot

Navigate to the root of your godot project (where the project.godot is residing) and start a new Neovim like this:

nvim --listen ./godothost

(on Windows you might have to specify a IP:port combination instead, like "127.0.0.1:9696")

Open menu Editor/Editor Settings/ then navigate to General/External/:

Tick Use external editor
Add nvim to Exec Path
Add --server ./godothost --remote-send "<C-\><C-N>:n {file}<CR>{line}G{col}|" to Exec Flags

now when you click on a script in godot it will open it in a new buffer in Neovim.