Make your vim/neovim as smart as VSCode.

---

Coc is an intellisense engine for vim8 & neovim.

It works on vim >= 8.0.1453 and neovim >= 0.3.1.

It's a completion framework and language server client which supports extension features of VSCode.

True snippet and additional text editing support

Floating windows require nightly build of neovim or vim >= 8.1.1522, follow steps in the faq.

Check out doc/coc.txt for the vim interface.

Why?

• 🚀 Fast: instant increment completion, increment buffer sync using buffer update events.
• 💎 Reliable: typed language, tested with CI.
• 🌟 Featured: full LSP support
• ❤️ Flexible: configured like VSCode, extensions work like in VSCode

Completion experience

You might be wondering why yet another completion engine since there is the already widely used [YouCompleteMe](https://github.com/Valloric/YouCompleteMe) and [deoplete.nvim](https://github.com/Shougo/deoplete.nvim).

Below are the reasons that led coc.nvim to build its own engine:

• Full LSP completion support, especially snippet and additionalTextEdit feature, you'll understand why it's awesome when you experience it with a coc extension like coc-tsserver.
• Asynchronous and parallel completion request, unless using vim sources, your vim will never be blocked.
• Does completion resolving on completion item change. The details from completion items are echoed after being selected, this feature requires the CompleteChanged autocmd to work.
• Incomplete request and cancel request support, only incomplete completion requests would be triggered on filtering completion items and cancellation requests are sent to servers only when necessary.
• Start completion without timer. The completion will start after you type the first letter of a word by default and is filtered with new input after the completion has finished. Other completion engines use a timer to trigger completion so you always have to wait after the typed character.
• Realtime buffer keywords. Coc will generate buffer keywords on buffer change in the background (with debounce), while some completion engines use a cache which isn't always correct. Plus, Locality bonus feature from VSCode is enabled by default.
• Filter completion items when possible. When you do a fuzzy filter with completion items, some completion engines will trigger a new completion, but coc.nvim will filter the items when possible which makes it much faster. Filtering completion items on backspace is also supported.

Table of contents

• Installation

  Install nodejs:

  curl -sL install-node.now.sh/lts | bash
  # Optional install yarn if you want install extension by CocInstall command
  curl --compressed -o- -L https://yarnpkg.com/install.sh | bash

  For vim-plug users:

  " Use release branch
  Plug 'neoclide/coc.nvim', {'branch': 'release'}
  " Or build from source code
  Plug 'neoclide/coc.nvim', {'do': 'yarn install --frozen-lockfile'}

  in your .vimrc or init.vim, then restart vim and run :PlugInstall.

  For other plugin managers, make sure use release branch.

  Note: The first time building from source code may be slow.

  Note: NixOS users must follow these steps:

  1. Install nodejs and yarn via nix-env or put them in /etc/nixos/configuration.nix
  2. sudo nixos-rebuild switch
  3. Plug 'neoclide/coc.nvim', {'do': 'yarn install --frozen-lockfile'}
  4. Don't forget to put: set shell=/bin/sh in your init.vim.

• Completion with sources

• Using snippets

• Using extensions

• Using list

• Using configuration file

• Using workspaceFolders

• Language servers

  • Supported features

  • Register custom language servers

    • Dart
    • C/C++/Objective-C
    • Rust
    • Go
    • PHP
    • Dockerfile
    • Bash
    • Lua
    • OCaml and ReasonML
    • PureScript
    • Flow
    • Haskell
    • vim/erb/markdown
    • Elixir
    • Python
    • Ruby
    • Scala
    • Latex
    • Elm
    • Fortran
    • Clojure
    • Julia

• Statusline integration

• Debug language server

• Debug coc.nvim

• F.A.Q

Completion sources

Completion from words in buffers and file paths completions are supported by default.

For other completion sources, check out:

• coc-sources: includes some common completion source extensions.
• coc-neco: viml completion support.
• coc-vimtex: vimtex integration.
• coc-neoinclude: neoinclude integration.
• coc-powershell: PowerShellEditorService integration.
• coc-lbdbq: email address completion.
• coc-browser: web browser words completion.

Or you can create a custom source.

Extensions

Extensions are more powerful than a configured language server. Check out Using coc extensions.

• coc-json for json.
• coc-tsserver for javascript and typescript.
• coc-html for html, handlebars and razor.
• coc-css for css, scss and less.
• coc-vetur for vue, use vetur.
• coc-phpls for php, use intelephense-docs.
• coc-java for java, use eclipse.jdt.ls.
• coc-solargraph for ruby, use solargraph.
• coc-rls for rust, use Rust Language Server
• coc-r-lsp for r, use R languageserver.
• coc-yaml for yaml
• coc-python for python, extension forked from vscode-python.
• coc-highlight provides default document symbol highlighting and color support.
• coc-emmet provides emmet suggestions in completion list.
• coc-snippets provides snippets solution.
• coc-lists provides some basic lists like fzf.vim.
• coc-git provides git integration.
• coc-yank provides yank highlights & history.
• coc-fsharp for fsharp.
• coc-svg for svg.
• coc-tailwindcss for tailwindcss.
• coc-angular for angular.
• coc-vimlsp for viml.

Plus more! To get a full list of coc extensions, search coc.nvim on npm, or use coc-marketplace, which can search and install extensions in coc.nvim directly.

Note: use :CocConfig to edit the configuration file. Completion & validation are supported after coc-json is installed.

Example vim configuration

Configuration is required to make coc.nvim easier to work with, since it doesn't change your key-mappings or vim options. This is done as much as possible to avoid conflict with your other plugins.

❗️Important: some vim plugins could change keymappings. Use a command like :verbose imap <tab> to make sure that your keymap has taken effect.

" if hidden is not set, TextEdit might fail.
set hidden

" Some servers have issues with backup files, see #649
set nobackup
set nowritebackup

" Better display for messages
set cmdheight=2

" You will have bad experience for diagnostic messages when it's default 4000.
set updatetime=300

" don't give |ins-completion-menu| messages.
set shortmess+=c

" always show signcolumns
set signcolumn=yes

" Use tab for trigger completion with characters ahead and navigate.
" Use command ':verbose imap <tab>' to make sure tab is not mapped by other plugin.
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" :
      \ <SID>check_back_space() ? "\<TAB>" :
      \ coc#refresh()
inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>"

function! s:check_back_space() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> to trigger completion.
inoremap <silent><expr> <c-space> coc#refresh()

" Use <cr> to confirm completion, `<C-g>u` means break undo chain at current position.
" Coc only does snippet and additional edit on confirm.
inoremap <expr> <cr> pumvisible() ? "\<C-y>" : "\<C-g>u\<CR>"

" Use `[c` and `]c` to navigate diagnostics
nmap <silent> [c <Plug>(coc-diagnostic-prev)
nmap <silent> ]c <Plug>(coc-diagnostic-next)

" Remap keys for gotos
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use K to show documentation in preview window
nnoremap <silent> K :call <SID>show_documentation()<CR>

function! s:show_documentation()
  if (index(['vim','help'], &filetype) >= 0)
    execute 'h '.expand('<cword>')
  else
    call CocAction('doHover')
  endif
endfunction

" Highlight symbol under cursor on CursorHold
autocmd CursorHold * silent call CocActionAsync('highlight')

" Remap for rename current word
nmap <leader>rn <Plug>(coc-rename)

" Remap for format selected region
xmap <leader>f  <Plug>(coc-format-selected)
nmap <leader>f  <Plug>(coc-format-selected)

augroup mygroup
  autocmd!
  " Setup formatexpr specified filetype(s).
  autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected')
  " Update signature help on jump placeholder
  autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
augroup end

" Remap for do codeAction of selected region, ex: `<leader>aap` for current paragraph
xmap <leader>a  <Plug>(coc-codeaction-selected)
nmap <leader>a  <Plug>(coc-codeaction-selected)

" Remap for do codeAction of current line
nmap <leader>ac  <Plug>(coc-codeaction)
" Fix autofix problem of current line
nmap <leader>qf  <Plug>(coc-fix-current)

" Use `:Format` to format current buffer
command! -nargs=0 Format :call CocAction('format')

" Use `:Fold` to fold current buffer
command! -nargs=? Fold :call     CocAction('fold', <f-args>)

" use `:OR` for organize import of current buffer
command! -nargs=0 OR   :call     CocAction('runCommand', 'editor.action.organizeImport')

" Add diagnostic info for https://github.com/itchyny/lightline.vim
let g:lightline = {
      \ 'colorscheme': 'wombat',
      \ 'active': {
      \   'left': [ [ 'mode', 'paste' ],
      \             [ 'cocstatus', 'readonly', 'filename', 'modified' ] ]
      \ },
      \ 'component_function': {
      \   'cocstatus': 'coc#status'
      \ },
      \ }



" Using CocList
" Show all diagnostics
nnoremap <silent> <space>a  :<C-u>CocList diagnostics<cr>
" Manage extensions
nnoremap <silent> <space>e  :<C-u>CocList extensions<cr>
" Show commands
nnoremap <silent> <space>c  :<C-u>CocList commands<cr>
" Find symbol of current document
nnoremap <silent> <space>o  :<C-u>CocList outline<cr>
" Search workspace symbols
nnoremap <silent> <space>s  :<C-u>CocList -I symbols<cr>
" Do default action for next item.
nnoremap <silent> <space>j  :<C-u>CocNext<CR>
" Do default action for previous item.
nnoremap <silent> <space>k  :<C-u>CocPrev<CR>
" Resume latest coc list
nnoremap <silent> <space>p  :<C-u>CocListResume<CR>

Trouble shooting

Try these steps when you have problem with coc.nvim.

• Make sure your vim version >= 8.0.1453 by command :version.
• If service failed to start, use command :CocInfo or :checkhealth on neovim.
• Checkout the log of coc.nvim by command :CocOpenLog.
• When you have issue with a languageserver, it's recommended to checkout the output

Backers

❤️ coc.nvim? Help us keep it alive by donating funds😘!

Feedback

• If you think Coc is useful, consider giving it a star.

• If you have a question, ask on gitter

• 中文用户请到 中文 gitter 讨论。

• If something is not working, create an issue.

License

MIT