Homebrew can install clangd along with LLVM:

$ brew install llvm

If you don’t want to use Homebrew, you can download the a binary release of LLVM from releases.llvm.org. Alongside bin/clangd you will need at least lib/clang/*/include:

$ cp clang+llvm-7.0.0/bin/clangd /usr/local/bin/clangd
$ cp -r clang+llvm-7.0.0/lib/clang/ /usr/local/lib/

Download and run the LLVM installer from releases.llvm.org.

The clang-tools package usually contains an old version of clangd.

Try to install the latest release (8.0):

$ sudo apt-get install clang-tools-8

If that is not found, at least clang-tools-7 should be available.

The clangd executable will be installed as /usr/bin/clangd-8. Make it the default clangd:

$ sudo update-alternatives --install /usr/bin/clangd clangd /usr/bin/clangd-8 100

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

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

YouCompleteMe supports clangd. However, clangd support is not turned on by default, so you must install YouCompleteMe 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 code 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.

LanguageClient-neovim has instructions for using clangd, and may be easier to install than YouCompleteMe.

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, though the interaction is quite poor (even with 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.

company-clang is enabled by default, and will interfere with clangd. Disable it in M-x customize-variable RET company-backends RET.

Completion still has some major limitations:

• completions are alphabetically sorted, not ranked.
• only pure-prefix completions are shown - no fuzzy matches.
• completion triggering seems to be a bit hit-and-miss.

Under the hood

• Debug logs: available in the EGLOT stderr 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.

tomv564/LSP 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 LSP: Enable Language Server Globally. Select 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.

• Debug logs: add "log_stderr": true
• Command-line flags and alternate clangd binary: inside the "clients": {"clangd": { ... } } section, add "command": ["/path/to/clangd", "-log=verbose"] etc.

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 you don’t have strong feelings about an editor, we suggest you try out VSCode, it has excellent language server support and most faithfully demonstrates what clangd can do.