Getting started

Clangd can be installed (along with LLVM) via Homebrew:

brew install llvm

or with MacPorts:

sudo port install clang-11

Download the LLVM installer from releases.llvm.org

Installing the clangd package will usually give you a slightly older version.

Try to install a packaged release (12.0):

sudo apt-get install clangd-12

If that’s not found, at least clangd-9 or clangd-8 should be available. Versions before 8 were part of the clang-tools package.

This will install clangd as /usr/bin/clangd-12. Make it the default clangd:

sudo update-alternatives --install /usr/bin/clangd clangd /usr/bin/clangd-12 100

Most distributions include clangd in a clangd package, in a clang-tools package, or in the full llvm distribution.

For some platforms, binaries are also available at releases.llvm.org.

Vim and Neovim have several plugins that can communicate with clangd.

YouCompleteMe

Supports both Vim and Neovim. Note that clangd support is not enabled by default in YouCompleteMe, you must install it with install.py --clangd-completer.

We recommend changing a couple of YCM’s default settings. In .vimrc add:

" Let clangd fully control code completion
let g:ycm_clangd_uses_ycmd_caching = 0
" Use installed clangd, not YCM-bundled clangd which doesn't get updates.
let g:ycm_clangd_binary_path = exepath("clangd")

You should see errors highlighted and completions as you type.

YouCompleteMe supports many of clangd’s features:

• code completion
• diagnostics and fixes (:YcmCompleter FixIt)
• find declarations, references, and definitions (:YcmCompleter GoTo etc)
• rename symbol (:YcmCompleter RefactorRename)

Under the hood:

• Debug logs: run :YcmDebugInfo to see clangd status, and :YcmToggleLogs to view clangd’s debug logs.

• Command-line flags: Set g:ycm_clangd_args in .vimrc, e.g.:

  let g:ycm_clangd_args = ['-log=verbose', '-pretty']
  

• Alternate clangd binary: set g:ycm_clangd_binary_path in .vimrc.

coc-clangd

Supports both Vim and Neovim. coc-clangd is an extension for coc.nvim, you need to install coc.nvim first.

:CocInstall coc-clangd in Vim/Neovim to install coc-clangd. coc-clangd will try to find clangd from your $PATH, if not found, run :CocCommand clangd.install to install the latest release from GitHub, or set clangd.path in :CocConfig to use custom clangd binary.

coc-clangd provides configurations for clangd, you can set them in :CocConfig:

{
  "clangd.path": "/path/to/custom/clangd",
  "clangd.arguments": ["--background-index", "--clang-tidy"],
  "clangd.fallbackFlags": ["-std=c++23"]
}

Check coc-clangd’s README for more options.

coc-clangd also provides commands to interact with clangd:

• :CocCommand clangd.switchSourceHeader, switch between source/header files
• :CocCommand clangd.symbolInfo, resolve symbol info under the cursor
• :CocCommand clangd.memoryUsage, show memory usage
• :CocCommand clangd.install, install latest release from GitHub
• :CocCommand clangd.update, check and update clangd from GitHub

There are two ways to get request/response logs from coc-clangd:

1. Set "clangd.trace.server": "verbose" in :CocConfig, and check the output in :CocCommand workspace.showOutput clangd.
2. Set "clangd.trace.file": "/tmp/clangd.log", clangd will output logs to the file.

Neovim built-in LSP client

Neovim only. Neovim has a built-in LSP client, which can be configured to work with clangd.

1. install nvim-lspconfig with your plugin manager
2. enable clangd in your init.lua: require'lspconfig'.clangd.setup{}
3. the ClangdSwitchSourceHeader and ClangdShowSymbolInfo commands will be enabled when you are in a C/C++ file
4. you can pass additional arguments to clangd to trace logs or enable more features:

local lspconfig = require('lspconfig')
lspconfig.clangd.setup({
  cmd = {'clangd', '--background-index', '--clang-tidy', '--log=verbose'},
  init_options = {
    fallbackFlags = { '-std=c++17' },
  },
})

You can also create your own LSP configuration by using the vim.lsp.start function. For more details, check :help vim.lsp.start or use clangd_extensions.nvim directly, with more off-spec features support.

eglot can be configured to work with clangd.

Install eglot with M-x package-install RET eglot RET.

Add the following to ~/.emacs to enable clangd:

(require 'eglot)
(add-to-list 'eglot-server-programs '((c++-mode c-mode) "clangd"))
(add-hook 'c-mode-hook 'eglot-ensure)
(add-hook 'c++-mode-hook 'eglot-ensure)

After restarting you should see diagnostics for errors in your code, and M-x completion-at-point should work.

eglot supports many of clangd’s features, with caveats:

• code completion, enhanced by company-mode, see below
• diagnostics and fixes
• find definitions and references (M-x xref-find-definitions etc)
• hover and highlights
• code actions (M-x eglot-code-actions)

company-mode

eglot does have basic integration with company-mode, which provides a more fluent completion UI.

You can install it with M-x package-install RET company RET, and enable it with M-x company-mode.

Under the hood

• Debug logs: available in the EGLOT events buffer.
• Command-line flags and alternate binary: instead of adding "clangd" to eglot-server-programs, add ("/path/to/clangd" "-log=verbose") etc.

The official extension is vscode-clangd and can be installed from within VSCode.

Choose View –> Extensions, then search for “clangd”. (Make sure the Microsoft C/C++ extension is not installed).

After restarting, you should see red underlines underneath errors, and you should get rich code completions including e.g. function parameters.

vscode-clangd has excellent support for all clangd features, including:

• code completion
• diagnostics and fixes
• find declarations, references, and definitions
• find symbol in file (Ctrl-P @foo) or workspace (Ctrl-P #foo)
• hover and highlights
• code actions

Under the hood

• Debug logs: when clangd is running, you should see “Clang Language Server” in the dropdown of the Output panel (View -> Output).
• Command-line flags: these can be passed in the clangd.arguments array in your settings.json. (File -> Preferences -> Settings).
• Alternate clangd binary: set the clangd.path string in settings.json.

sublimelsp/LSP together with sublimelsp/LSP-clangd works with clangd out of the box.

Select Tools–>Install Package Control (if you haven’t installed it yet).

Press Ctrl-Shift-P and select Package Control: Install Package. Select LSP.

Press Ctrl-Shift-P and select Package Control: Install Package. Select LSP-clangd.

Open a C++ file, and you should see diagnostics and completion:

The LSP package has excellent support for all most clangd features, including:

• code completion (a bit noisy due to how snippets are presented)
• diagnostics and fixes
• find definition and references
• hover and highlights
• code actions

Under the hood

Settings can be tweaked under Preferences–>Package Settings–>LSP–>servers–>LSP-clangd or from the Command Palette by selecting Preferences: LSP-clangd Settings.

• Command-line flags and alternate clangd binary: check inside Preferences: LSP-clangd Settings for relevant option and documentation.

There is a directory of LSP clients at langserver.org.

A generic client should be configured to run the command clangd, and communicate via the language server protocol on standard input/output.

If your project builds with CMake, it can generate this file. You should enable it with:

cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1

compile_commands.json will be written to your build directory. If your build directory is $SRC or $SRC/build, clangd will find it. Otherwise, symlink or copy it to $SRC, the root of your source tree.

ln -s ~/myproject-build/compile_commands.json ~/myproject/

Bazel can generate this file via this extractor extension. Refer to instructions in the project README; it is intended for use with clangd.

Bear is a tool to generate a compile_commands.json file by recording a complete build.

For a make-based build, you can run make clean; bear -- make to generate the file (and run a clean build!).

On Windows, a tool similar to Bear called compiledb can be used.