{
  "ada_ls": "https://github.com/AdaCore/ada_language_server Installation instructions\ncan be found\n[here](https://github.com/AdaCore/ada_language_server#Install).\nWorkspace-specific\n[settings](https://github.com/AdaCore/ada_language_server/blob/master/doc/settings.md)\nsuch as `projectFile` can be provided in a `.als.json` file at the root\nof the workspace. Alternatively, configuration may be passed as a\n\"settings\" object to `vim.lsp.config('ada_ls', {})`:\n\n``` lua\nvim.lsp.config('ada_ls', {\n    settings = {\n      ada = {\n        projectFile = \"project.gpr\";\n        scenarioVariables = { ... };\n      }\n    }\n})\n```",
  "agda_ls": "https://github.com/agda/agda-language-server Language Server for Agda.",
  "aiken": "https://github.com/aiken-lang/aiken A language server for Aiken\nProgramming Language.\n[Installation](https://aiken-lang.org/installation-instructions) It can\nbe i",
  "air": "https://github.com/posit-dev/air Air is an R formatter and language\nserver, written in Rust. Refer to the\n[documentation](https://posit-dev.github.io/air/editors.html) for more\ndetails.",
  "alloy_ls": "https://github.com/AlloyTools/org.alloytools.alloy Alloy is a formal\nspecification language for describing structures and a tool for\nexploring them. You may also need to configure the filetype for Alloy\n(\\*.als) files:\n\n    autocmd BufNewFile,BufRead *.als set filetype=alloy\n\nor\n\n``` lua\nvim.filetype.add({\n  pattern = {\n    ['.*/*.als'] = 'alloy',\n  },\n})\n```\n\nAlternatively, you may use a syntax plugin like\nhttps://github.com/runoshun/vim-alloy.",
  "anakin_language_server": "https://pypi.org/project/anakin-language-server/\n`anakin-language-server` is yet another Jedi Python language server.\nAvailable options: \\* Initialization:\nhttps://github.com/muffinmad/anakin-language-server#initialization-option\n\\* Configuration:\nhttps://github.com/muffinmad/anakin-language-server#configuration-options",
  "angularls": "https://github.com/angular/vscode-ng-language-service\n`angular-language-server` can be installed via npm\n`npm install -g @angular/language-server`.\n\n``` lua\nlocal project_library_path = \"/path/to/project/lib\"\nlocal cmd = {\"ngserver\", \"--stdio\", \"--tsProbeLocations\", project_library_path , \"--ngProbeLocations\", project_library_path}\nvim.lsp.config('angularls', {\n  cmd = cmd,\n})\n```",
  "ansiblels": "https://github.com/ansible/vscode-ansible Language server for the\nansible configuration management tool. `ansible-language-server` can be\ninstalled via `npm`:\n\n``` sh\nnpm install -g @ansible/ansible-language-server\n```",
  "antlersls": "https://www.npmjs.com/package/antlers-language-server `antlersls` can be\ninstalled via `npm`:\n\n``` sh\nnpm install -g antlers-language-server\n```",
  "apex_ls": "",
  "arduino_language_server": "https://github.com/arduino/arduino-language-server Language server for\nArduino The `arduino-language-server` can be installed by running:\n\n    go install github.com/arduino/arduino-language-server@latest\n\nThe `arduino-cli` tool must also be installed. Follow [these\ninstallation\ninstructions](https://arduino.github.io/arduino-cli/latest/installation/)\nfor your platform. After installing `arduino-cli`, follow [these\ninstructions](https://arduino.github.io/arduino-cli/latest/getting-started/#create-a-configuration-file)\nfor generating a configuration file if you haven't done so already, and\nmake sure you [install any relevant platforms\nlibraries](https://arduino.github.io/arduino-cli/latest/getting-started/#install-the-core-for-your-board).\nThe language server also requires `clangd` to be installed. Follow\n[these installation instructions](https://clangd.llvm.org/installation)\nfor your platform. If you don't have a sketch yet create one.\n\n``` sh\n$ arduino-cli sketch new test\n$ cd test\n```\n\nYou will need a `sketch.yaml` file in order for the language server to\nunderstand your project. It will also save you passing options to\n`arduino-cli` each time you compile or upload a file. You can generate\nthe file by using the following commands. First gather some information\nabout your board. Make sure your board is connected and run the\nfollowing:\n\n``` sh\n$ arduino-cli board list\nPort         Protocol Type              Board Name  FQBN            Core\n/dev/ttyACM0 serial   Serial Port (USB) Arduino Uno arduino:avr:uno arduino:avr\n```\n\nThen generate the file:\n\n``` sh\narduino-cli board attach -p /dev/ttyACM0 -b arduino:avr:uno test.ino\n```\n\nThe resulting file should look like this:\n\n``` yaml\ndefault_fqbn: arduino:avr:uno\ndefault_port: /dev/ttyACM0\n```\n\nYour folder structure should look like this:\n\n    .\n    ├── test.ino\n    └── sketch.yaml\n\nFor further instructions about configuration options, run\n`arduino-language-server --help`. Note that an upstream bug makes\nkeywords in some cases become undefined by the language server. Ref:\nhttps://github.com/arduino/arduino-ide/issues/159",
  "asm_lsp": "https://github.com/bergercookie/asm-lsp Language Server for NASM/GAS/GO\nAssembly `asm-lsp` can be installed via cargo: cargo install asm-lsp",
  "ast_grep": "https://ast-grep.github.io/ ast-grep(sg) is a fast and polyglot tool for\ncode structural search, lint, rewriting at large scale. ast-grep LSP\nonly works in projects that have `sgconfig.y[a]ml` in their root\ndirectories.\n\n``` sh\nnpm install [-g] @ast-grep/cli\n```",
  "astro": "https://github.com/withastro/language-tools/tree/main/packages/language-server\n`astro-ls` can be installed via `npm`:\n\n``` sh\nnpm install -g @astrojs/language-server\n```",
  "atlas": "https://github.com/ariga/atlas Language server for Atlas config and\nschema files. You may also need to configure the filetype for \\*.hcl\nfiles:\n\n``` vim\nautocmd BufNewFile,BufRead atlas.hcl set filetype=atlas-config\nautocmd BufNewFile,BufRead *.my.hcl set filetype=atlas-schema-mysql\nautocmd BufNewFile,BufRead *.pg.hcl set filetype=atlas-schema-postgresql\nautocmd BufNewFile,BufRead *.lt.hcl set filetype=atlas-schema-sqlite\nautocmd BufNewFile,BufRead *.ch.hcl set filetype=atlas-schema-clickhouse\nautocmd BufNewFile,BufRead *.ms.hcl set filetype=atlas-schema-mssql\nautocmd BufNewFile,BufRead *.rs.hcl set filetype=atlas-schema-redshift\nautocmd BufNewFile,BufRead *.test.hcl set filetype=atlas-test\nautocmd BufNewFile,BufRead *.plan.hcl set filetype=atlas-plan\nautocmd BufNewFile,BufRead *.rule.hcl set filetype=atlas-rule\n```\n\nor\n\n``` lua\nvim.filetype.add({\n  filename = {\n    ['atlas.hcl'] = 'atlas-config',\n  },\n  pattern = {\n    ['.*/*.my.hcl'] = 'atlas-schema-mysql',\n    ['.*/*.pg.hcl'] = 'atlas-schema-postgresql',\n    ['.*/*.lt.hcl'] = 'atlas-schema-sqlite',\n    ['.*/*.ch.hcl'] = 'atlas-schema-clickhouse',\n    ['.*/*.ms.hcl'] = 'atlas-schema-mssql',\n    ['.*/*.rs.hcl'] = 'atlas-schema-redshift',\n    ['.*/*.test.hcl'] = 'atlas-test',\n    ['.*/*.plan.hcl'] = 'atlas-plan',\n    ['.*/*.rule.hcl'] = 'atlas-rule',\n  },\n})\n```\n\nOptionally, tell treesitter to treat Atlas filetypes as HCL for better\nsyntax highlighting:\n\n``` lua\nvim.treesitter.language.register('hcl', 'atlas-config')\nvim.treesitter.language.register('hcl', 'atlas-schema-mysql')\nvim.treesitter.language.register('hcl', 'atlas-schema-postgresql')\nvim.treesitter.language.register('hcl', 'atlas-schema-sqlite')\nvim.treesitter.language.register('hcl', 'atlas-schema-clickhouse')\nvim.treesitter.language.register('hcl', 'atlas-schema-mssql')\nvim.treesitter.language.register('hcl', 'atlas-schema-redshift')\nvim.treesitter.language.register('hcl', 'atlas-test')\nvim.treesitter.language.register('hcl', 'atlas-plan')\nvim.treesitter.language.register('hcl', 'atlas-rule')\n```",
  "atopile": "https://atopile.io/ A language server for atopile Programming Language.\nIt comes with the atopile compiler, for installation see: [Installing\natopile](https://docs.atopile.io/atopile/guides/install)",
  "autohotkey_lsp": "https://github.com/thqby/vscode-autohotkey2-lsp AutoHotkey v2.0 LSP\nimplementation NOTE: AutoHotkey is Windows-only.",
  "autotools_ls": "https://github.com/Freed-Wu/autotools-language-server\n`autotools-language-server` can be installed via `pip`:\n\n``` sh\npip install autotools-language-server\n```\n\nLanguage server for autoconf, automake and make using tree sitter in\npython.",
  "awk_ls": "https://github.com/Beaglefoot/awk-language-server/ `awk-language-server`\ncan be installed via `npm`:\n\n``` sh\nnpm install -g awk-language-server\n```",
  "azure_pipelines_ls": "https://github.com/microsoft/azure-pipelines-language-server An Azure\nPipelines language server `azure-pipelines-ls` can be installed via\n`npm`:\n\n``` sh\nnpm install -g azure-pipelines-language-server\n```\n\nBy default `azure-pipelines-ls` will only work in files named\n`azure-pipelines.yml`, this can be changed by providing additional\nsettings like so:\n\n``` lua\nvim.lsp.config('azure_pipelines_ls', {\n  ... -- other configuration\n  settings = {\n      yaml = {\n          schemas = {\n              [\"https://raw.githubusercontent.com/microsoft/azure-pipelines-vscode/master/service-schema.json\"] = {\n                  \"/azure-pipeline*.y*l\",\n                  \"/*.azure*\",\n                  \"Azure-Pipelines/**/*.y*l\",\n                  \"Pipelines/*.y*l\",\n              },\n          },\n      },\n  },\n})\n```\n\nThe Azure Pipelines LSP is a fork of `yaml-language-server` and as such\nthe same settings can be passed to it as `yaml-language-server`.",
  "bacon_ls": "https://github.com/crisidev/bacon-ls A Language Server Protocol wrapper\nfor [bacon](https://dystroy.org/bacon/). It offers\ntextDocument/diagnostic and workspace/diagnostic capabilities for Rust\nworkspaces using the Bacon export locations file. It requires `bacon`\nand `bacon-ls` to be installed on the system using\n[mason.nvim](https://github.com/williamboman/mason.nvim) or manually\n\n``` sh\n$ cargo install --locked bacon bacon-ls\n```\n\nSettings can be changed using the `init_options` dictionary:util\n\n``` lua\ninit_options = {\n    -- Bacon export filename (default: .bacon-locations).\n    locationsFile = \".bacon-locations\",\n    -- Try to update diagnostics every time the file is saved (default: true).\n    updateOnSave = true,\n    --  How many milliseconds to wait before updating diagnostics after a save (default: 1000).\n    updateOnSaveWaitMillis = 1000,\n    -- Try to update diagnostics every time the file changes (default: true).\n    updateOnChange = true,\n    -- Try to validate that bacon preferences are setup correctly to work with bacon-ls (default: true).\n    validateBaconPreferences = true,\n    -- f no bacon preferences file is found, create a new preferences file with the bacon-ls job definition (default: true).\n    createBaconPreferencesFile = true,\n    -- Run bacon in background for the bacon-ls job (default: true)\n    runBaconInBackground = true,\n    -- Command line arguments to pass to bacon running in background (default \"--headless -j bacon-ls\")\n    runBaconInBackgroundCommandArguments = \"--headless -j bacon-ls\",\n    -- How many milliseconds to wait between background diagnostics check to synchronize all open files (default: 2000).\n    synchronizeAllOpenFilesWaitMillis = 2000,\n}\n```",
  "ballerina": "Ballerina language server The Ballerina language's CLI tool comes with\nits own language server implementation. The `bal` command line tool must\nbe installed and available in your system's PATH.",
  "basedpyright": "https://detachhead.github.io/basedpyright `basedpyright`, a static type\nchecker and language server for python",
  "bashls": "https://github.com/bash-lsp/bash-language-server `bash-language-server`\ncan be installed via `npm`:\n\n``` sh\nnpm i -g bash-language-server\n```\n\nLanguage server for bash, written using tree sitter in typescript.",
  "basics_ls": "https://github.com/antonk52/basics-language-server/ Buffer, path, and\nsnippet completion\n\n``` sh\nnpm install -g basics-language-server\n```",
  "bazelrc_lsp": "https://github.com/salesforce-misc/bazelrc-lsp `bazelrc-lsp` is a LSP\nfor `.bazelrc` configuration files. The `.bazelrc` file type is not\ndetected automatically, you can register it manually (see below) or\noverride the filetypes:\n\n``` lua\nvim.filetype.add {\n  pattern = {\n    ['.*.bazelrc'] = 'bazelrc',\n  },\n}\n```",
  "beancount": "https://github.com/polarmutex/beancount-language-server#installation See\nhttps://github.com/polarmutex/beancount-language-server#configuration\nfor configuration options",
  "bicep": "https://github.com/azure/bicep Bicep language server Bicep language\nserver can be installed by downloading and extracting a release of\nbicep-langserver.zip from [Bicep GitHub\nreleases](https://github.com/Azure/bicep/releases). Bicep language\nserver requires the [dotnet-sdk](https://dotnet.microsoft.com/download)\nto be installed. Neovim does not have built-in support for the bicep\nfiletype which is required for lspconfig to automatically launch the\nlanguage server. Filetype detection can be added via an autocmd:\n\n``` lua\nvim.cmd [[ autocmd BufNewFile,BufRead *.bicep set filetype=bicep ]]\n```\n\n**By default, bicep language server does not have a `cmd` set.** This is\nbecause nvim-lspconfig does not make assumptions about your path. You\nmust add the following to your init.vim or init.lua to set `cmd` to the\nabsolute path (\\$HOME and \\~ are not expanded) of the unzipped run\nscript or binary.\n\n``` lua\nlocal bicep_lsp_bin = \"/path/to/bicep-langserver/Bicep.LangServer.dll\"\nvim.lsp.config('bicep', {\n    cmd = { \"dotnet\", bicep_lsp_bin };\n    ...\n})\n```\n\nTo download the latest release and place in\n/usr/local/bin/bicep-langserver:\n\n``` bash\n(cd $(mktemp -d) \\\n    && curl -fLO https://github.com/Azure/bicep/releases/latest/download/bicep-langserver.zip \\\n    && rm -rf /usr/local/bin/bicep-langserver \\\n    && unzip -d /usr/local/bin/bicep-langserver bicep-langserver.zip)\n```",
  "biome": "https://biomejs.dev Toolchain of the web. [Successor of\nRome](https://biomejs.dev/blog/annoucing-biome).\n\n``` sh\nnpm install [-g] @biomejs/biome\n```\n\n**Monorepo support**\n\n`biome` supports monorepos by default. It will automatically find the\n`biome.json` corresponding to the package you are working on, as\ndescribed in the\n[documentation](https://biomejs.dev/guides/big-projects/#monorepo). This\nworks without the need of spawning multiple instances of `biome`, saving\nmemory.",
  "bitbake_language_server": "https://github.com/Freed-Wu/bitbake-language-server\n`bitbake-language-server` can be installed via `pip`:\n\n``` sh\npip install bitbake-language-server\n```\n\nLanguage server for bitbake.",
  "blueprint_ls": "https://gitlab.gnome.org/jwestman/blueprint-compiler\n`blueprint-compiler` can be installed via your system package manager.\nLanguage server for the blueprint markup language, written in python and\npart of the blueprint-compiler.",
  "bqls": "https://github.com/kitagry/bqls The `bqls` BigQuery language server can\nbe installed by running:\n\n``` sh\n$ go install github.com/kitagry/bqls@latest\n```",
  "bright_script": "https://github.com/RokuCommunity/brighterscript `brightscript` can be\ninstalled via `npm`:\n\n``` sh\nnpm install -g brighterscript\n```",
  "brioche": "https://github.com/brioche-dev/brioche `Brioche Language Server`.",
  "bsl_ls": "https://github.com/1c-syntax/bsl-language-server Language Server\nProtocol implementation for 1C (BSL) - 1C:Enterprise 8 and OneScript\nlanguages.",
  "buck2": "https://github.com/facebook/buck2 Build system, successor to Buck To\nbetter detect Buck2 project files, the following can be added:\n\n    vim.cmd [[ autocmd BufRead,BufNewFile *.bxl,BUCK,TARGETS set filetype=bzl ]]",
  "buddy_ls": "https://github.com/buddy-compiler/buddy-mlir#buddy-lsp-server The\nLanguage Server for the buddy-mlir, a drop-in replacement for\nmlir-lsp-server, supporting new dialects defined in buddy-mlir.\n`buddy-lsp-server` can be installed at the buddy-mlir repository\n(buddy-compiler/buddy-mlir)",
  "buf_ls": "",
  "bzl": "https://bzl.io/ https://docs.stack.build/docs/cli/installation\nhttps://docs.stack.build/docs/vscode/starlark-language-server",
  "c3_lsp": "https://github.com/pherrymason/c3-lsp Language Server for c3.",
  "cairo_ls": "[Cairo Language\nServer](https://github.com/starkware-libs/cairo/tree/main/crates/cairo-lang-language-server)\nFirst, install Cairo following [this\ntutorial](https://book.cairo-lang.org/ch01-01-installation.html) Then\nenable Cairo Language Server in your Lua configuration.\n\n``` lua\nvim.lsp.enable('cairo_ls')\n```\n\n*cairo-language-server is still under active development, some features\nmight not work yet !*",
  "ccls": "https://github.com/MaskRay/ccls/wiki ccls relies on a [JSON compilation\ndatabase](https://clang.llvm.org/docs/JSONCompilationDatabase.html)\nspecified as compile_commands.json or, for simpler projects, a .ccls.\nFor details on how to automatically generate one using CMake look\n[here](https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html).\nAlternatively, you can use [Bear](https://github.com/rizsotto/Bear).\nCustomization options are passed to ccls at initialization time via\ninit_options, a list of available options can be found\n[here](https://github.com/MaskRay/ccls/wiki/Customization#initialization-options).\nFor example:\n\n``` lua\nvim.lsp.config(\"ccls\", {\n  init_options = {\n    compilationDatabaseDirectory = \"build\";\n    index = {\n      threads = 0;\n    };\n    clang = {\n      excludeArgs = { \"-frounding-math\"} ;\n    };\n  }\n})\n```",
  "cds_lsp": "https://cap.cloud.sap/docs/ `cds-lsp` can be installed via `npm`:\n\n``` sh\nnpm i -g @sap/cds-lsp\n```",
  "cir_lsp_server": "https://llvm.github.io/clangir The Language Server for the LLVM ClangIR\nlanguage `cir-lsp-server` can be installed at the llvm-project\nrepository (https://github.com/llvm/llvm-project)",
  "circom-lsp": "[Circom Language Server](https://github.com/rubydusa/circom-lsp)\n`circom-lsp`, the language server for the Circom language.",
  "clangd": "https://clangd.llvm.org/installation.html - **NOTE:** Clang \\>= 11 is\nrecommended! See\n[#23](https://github.com/neovim/nvim-lspconfig/issues/23). - If\n`compile_commands.json` lives in a build directory, you should symlink\nit to the root of your source tree.\n`ln -s /path/to/myproject/build/compile_commands.json /path/to/myproject/` -\nclangd relies on a [JSON compilation\ndatabase](https://clang.llvm.org/docs/JSONCompilationDatabase.html)\nspecified as compile_commands.json, see\nhttps://clangd.llvm.org/installation#compile_commandsjson",
  "clarinet": "https://github.com/hirosystems/clarinet Clarinet is the fastest way to\nbuild, test, and deploy smart contracts on the Stacks blockchain.",
  "clojure_lsp": "https://github.com/clojure-lsp/clojure-lsp Clojure Language Server",
  "cmake": "https://github.com/regen100/cmake-language-server CMake LSP\nImplementation",
  "cobol_ls": "Cobol language support",
  "codebook": "https://github.com/blopker/codebook An unholy spell checker for code.\n`codebook-lsp` can be installed by following the instructions\n[here](https://github.com/blopker/codebook/blob/main/README.md#installation).\nThe default `cmd` assumes that the `codebook-lsp` binary can be found in\n`$PATH`.",
  "coffeesense": "https://github.com/phil294/coffeesense CoffeeSense Language Server\n`coffeesense-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g coffeesense-language-server\n```",
  "contextive": "https://github.com/dev-cycles/contextive Language Server for Contextive.\nContextive allows you to define terms in a central file and provides\nauto-completion suggestions and hover panels for these terms wherever\nthey're used. To install the language server, you need to download the\nappropriate [GitHub release\nasset](https://github.com/dev-cycles/contextive/releases/) for your\noperating system and architecture. After the download unzip the\nContextive.LanguageServer binary and copy the file into a folder that is\nincluded in your system's PATH.",
  "copilot": "https://www.npmjs.com/package/@github/copilot-language-server The\nCopilot Language Server enables any editor or IDE to integrate with\nGitHub Copilot via [the language server\nprotocol](https://microsoft.github.io/language-server-protocol/).\n**[GitHub Copilot](https://github.com/features/copilot)** is an AI pair\nprogrammer tool that helps you write code faster and smarter. **Sign up\nfor [GitHub Copilot Free](https://github.com/settings/copilot)!** Please\nsee [terms of use for GitHub\nCopilot](https://docs.github.com/en/site-policy/github-terms/github-terms-for-additional-products-and-features#github-copilot)\nYou need to enable `:help lsp-inline-completion` to receive suggestions.\nFor example, you can enable it in the LspAttach event:\n\n``` lua\nvim.api.nvim_create_autocmd('LspAttach', {\n  callback = function(args)\n    local bufnr = args.buf\n    local client = assert(vim.lsp.get_client_by_id(args.data.client_id))\n    if client:supports_method(vim.lsp.protocol.Methods.textDocument_inlineCompletion, bufnr) then\n      vim.lsp.inline_completion.enable(true, { bufnr = bufnr })\n      vim.keymap.set(\n        'i',\n        '<C-F>',\n        vim.lsp.inline_completion.get,\n        { desc = 'LSP: accept inline completion', buffer = bufnr }\n      )\n      vim.keymap.set(\n        'i',\n        '<C-G>',\n        vim.lsp.inline_completion.select,\n        { desc = 'LSP: switch inline completion', buffer = bufnr }\n      )\n    end\n  end\n})\n```",
  "coq_lsp": "https://github.com/ejgallego/coq-lsp/",
  "crystalline": "https://github.com/elbywan/crystalline Crystal language server.",
  "csharp_ls": "https://github.com/razzmatazz/csharp-language-server Language Server for\nC#. csharp-ls requires the\n[dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. The\npreferred way to install csharp-ls is with\n`dotnet tool install --global csharp-ls`.",
  "cspell_ls": "[cspell language server](https://github.com/vlabo/cspell-lsp)",
  "css_variables": "https://github.com/vunguyentuan/vscode-css-variables/tree/master/packages/css-variables-language-server\nCSS variables autocompletion and go-to-definition\n`css-variables-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g css-variables-language-server\n```",
  "cssls": "https://github.com/hrsh7th/vscode-langservers-extracted\n`css-languageserver` can be installed via `npm`:\n\n``` sh\nnpm i -g vscode-langservers-extracted\n```\n\nNeovim does not currently include built-in snippets.\n`vscode-css-language-server` only provides completions when snippet\nsupport is enabled. To enable completion, install a snippet plugin and\nadd the following override to your language client capabilities during\nsetup.\n\n``` lua\n--Enable (broadcasting) snippet capability for completion\nlocal capabilities = vim.lsp.protocol.make_client_capabilities()\ncapabilities.textDocument.completion.completionItem.snippetSupport = true\nvim.lsp.config('cssls', {\n  capabilities = capabilities,\n})\n```",
  "cssmodules_ls": "https://github.com/antonk52/cssmodules-language-server Language server\nfor autocompletion and go-to-definition functionality for CSS modules.\nYou can install cssmodules-language-server via npm:\n\n``` sh\nnpm install -g cssmodules-language-server\n```",
  "cucumber_language_server": "https://cucumber.io https://github.com/cucumber/common\nhttps://www.npmjs.com/package/@cucumber/language-server Language server\nfor Cucumber. `cucumber-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g @cucumber/language-server\n```",
  "cue": "https://github.com/cue-lang/cue CUE makes it easy to validate data,\nwrite schemas, and ensure configurations align with policies.",
  "custom_elements_ls": "https://github.com/Matsuuu/custom-elements-language-server\n`custom-elements-languageserver` depends on `typescript`. Both packages\ncan be installed via `npm`:\n\n``` sh\nnpm install -g typescript custom-elements-languageserver\n```\n\nTo configure typescript language server, add a\n[`tsconfig.json`](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)\nor\n[`jsconfig.json`](https://code.visualstudio.com/docs/languages/jsconfig)\nto the root of your project. Here's an example that disables type\nchecking in JavaScript files.\n\n``` json\n{\n  \"compilerOptions\": {\n    \"module\": \"commonjs\",\n    \"target\": \"es6\",\n    \"checkJs\": false\n  },\n  \"exclude\": [\n    \"node_modules\"\n  ]\n}\n```",
  "cypher_ls": "https://github.com/neo4j/cypher-language-support/tree/main/packages/language-server\n`cypher-language-server`, language server for Cypher query language.\nPart of the umbrella project cypher-language-support:\nhttps://github.com/neo4j/cypher-language-support\n`cypher-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g @neo4j-cypher/language-server\n```",
  "daedalus_ls": "",
  "dafny": "Support for the Dafny language server.",
  "dagger": "https://github.com/dagger/cuelsp Dagger's lsp server for cuelang.",
  "dartls": "https://github.com/dart-lang/sdk/tree/master/pkg/analysis_server/tool/lsp_spec\nLanguage server for dart.",
  "dcmls": "https://dcm.dev/ Language server for DCM analyzer.",
  "debputy": "https://salsa.debian.org/debian/debputy Language Server for Debian\npackages.",
  "denols": "https://github.com/denoland/deno Deno's built-in language server To\nappropriately highlight codefences returned from denols, you will need\nto augment vim.g.markdown_fenced languages in your init.lua. Example:\n\n``` lua\nvim.g.markdown_fenced_languages = {\n  \"ts=typescript\"\n}\n```",
  "dhall_lsp_server": "https://github.com/dhall-lang/dhall-haskell/tree/master/dhall-lsp-server\nlanguage server for dhall `dhall-lsp-server` can be installed via cabal:\n\n``` sh\ncabal install dhall-lsp-server\n```\n\nprebuilt binaries can be found\n[here](https://github.com/dhall-lang/dhall-haskell/releases).",
  "diagnosticls": "https://github.com/iamcco/diagnostic-languageserver Diagnostic language\nserver integrate with linters.",
  "digestif": "https://github.com/astoff/digestif Digestif is a code analyzer, and a\nlanguage server, for LaTeX, ConTeXt et caterva. It provides\ncontext-sensitive completion, documentation, code navigation, and\nrelated functionality to any text editor that speaks the LSP protocol.",
  "djls": "https://github.com/joshuadavidthomas/django-language-server `djls`, a\nlanguage server for the Django web framework.",
  "djlsp": "https://github.com/fourdigits/django-template-lsp `djlsp`, a language\nserver for Django templates.",
  "docker_compose_language_service": "https://github.com/microsoft/compose-language-service This project\ncontains a language service for Docker Compose.\n`compose-language-service` can be installed via `npm`:\n\n``` sh\nnpm install @microsoft/compose-language-service\n```\n\nNote: If the docker-compose-langserver doesn't startup when entering a\n`docker-compose.yaml` file, make sure that the filetype is\n`yaml.docker-compose`. You can set with:\n`:set filetype=yaml.docker-compose`.",
  "docker_language_server": "https://github.com/docker/docker-language-server\n`docker-langserver-server` can be installed via `go`:\n\n``` sh\ngo install github.com/docker/docker-language-server/cmd/docker-language-server@latest\n```",
  "dockerls": "https://github.com/rcjsuen/dockerfile-language-server-nodejs\n`docker-langserver` can be installed via `npm`:\n\n``` sh\nnpm install -g dockerfile-language-server-nodejs\n```\n\nAdditional configuration can be applied in the following way:\n\n``` lua\nvim.lsp.config('dockerls', {\n    settings = {\n        docker = {\n        languageserver = {\n            formatter = {\n            ignoreMultilineInstructions = true,\n        },\n        },\n    }\n    }\n})\n```",
  "dolmenls": "https://github.com/Gbury/dolmen/blob/master/doc/lsp.md `dolmenls` can be\ninstalled via `opam`\n\n``` sh\nopam install dolmen_lsp\n```",
  "dotls": "https://github.com/nikeee/dot-language-server `dot-language-server` can\nbe installed via `npm`:\n\n``` sh\nnpm install -g dot-language-server\n```",
  "dprint": "https://github.com/dprint/dprint Pluggable and configurable code\nformatting platform written in Rust.",
  "ds_pinyin_lsp": "https://github.com/iamcco/ds-pinyin-lsp Dead simple Pinyin language\nserver for input Chinese without IME(input method). To install, download\nthe latest [release](https://github.com/iamcco/ds-pinyin-lsp/releases)\nand ensure `ds-pinyin-lsp` is on your path. And make ensure the database\nfile `dict.db3` is also downloaded. And put the path to `dict.dbs` in\nthe following code.\n\n``` lua\nvim.lsp.config('ds_pinyin_lsp', {\n    init_options = {\n        db_path = \"your_path_to_database\"\n    }\n})\n```",
  "dts_lsp": "`dts-lsp` is an LSP for Devicetree files built on top of\ntree-sitter-devicetree grammar. Language servers can be used in many\neditors, such as Visual Studio Code, Emacs or Vim Install `dts-lsp` from\nhttps://github.com/igor-prusov/dts-lsp and add it to path `dts-lsp`\ndoesn't require any configuration. More about Devicetree:\nhttps://www.devicetree.org/\nhttps://docs.zephyrproject.org/latest/build/dts/index.html",
  "earthlyls": "https://github.com/glehmann/earthlyls A fast language server for\nearthly.",
  "ecsact": "https://github.com/ecsact-dev/ecsact_lsp_server Language server for\nEcsact. The default cmd assumes `ecsact_lsp_server` is in your PATH.\nTypically from the Ecsact SDK: https://ecsact.dev/start",
  "efm": "",
  "elixirls": "https://github.com/elixir-lsp/elixir-ls `elixir-ls` can be installed by\nfollowing the instructions\n[here](https://github.com/elixir-lsp/elixir-ls#building-and-running). 1.\nDownload the zip from\nhttps://github.com/elixir-lsp/elixir-ls/releases/latest/ 2. Unzip it and\nmake it executable.\n`bash    unzip elixir-ls.zip -d /path/to/elixir-ls    # Unix    chmod +x /path/to/elixir-ls/language_server.sh`\n**By default, elixir-ls doesn't have a `cmd` set.** This is because\nnvim-lspconfig does not make assumptions about your path. You must add\nthe following to your init.vim or init.lua to set `cmd` to the absolute\npath (\\$HOME and \\~ are not expanded) of your unzipped elixir-ls.\n\n``` lua\nvim.lsp.config('elixirls', {\n    -- Unix\n    cmd = { \"/path/to/elixir-ls/language_server.sh\" };\n    -- Windows\n    cmd = { \"/path/to/elixir-ls/language_server.bat\" };\n    ...\n})\n```\n\n'root_dir' is chosen like this: if two or more directories containing\n`mix.exs` were found when searching directories upward, the second one\n(higher up) is chosen, with the assumption that it is the root of an\numbrella app. Otherwise the directory containing the single mix.exs that\nwas found is chosen.",
  "elmls": "https://github.com/elm-tooling/elm-language-server#installation If you\ndon't want to use Nvim to install it, then you can use:\n\n``` sh\nnpm install -g elm elm-test elm-format @elm-tooling/elm-language-server\n```",
  "elp": "https://whatsapp.github.io/erlang-language-platform ELP integrates\nErlang into modern IDEs via the language server protocol and was\ninspired by rust-analyzer.",
  "ember": "https://github.com/ember-tooling/ember-language-server\n`ember-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g @ember-tooling/ember-language-server\n```",
  "emmet_language_server": "https://github.com/olrtg/emmet-language-server Package can be installed\nvia `npm`:\n\n``` sh\nnpm install -g @olrtg/emmet-language-server\n```",
  "emmet_ls": "https://github.com/aca/emmet-ls Package can be installed via `npm`:\n\n``` sh\nnpm install -g emmet-ls\n```",
  "emmylua_ls": "https://github.com/EmmyLuaLs/emmylua-analyzer-rust Emmylua Analyzer\nRust. Language Server for Lua. `emmylua_ls` can be installed using\n`cargo` by following the instructions\\[here\\]\n(https://github.com/EmmyLuaLs/emmylua-analyzer-rust?tab=readme-ov-file#install).\nThe default `cmd` assumes that the `emmylua_ls` binary can be found in\n`$PATH`. It might require you to provide cargo binaries installation\npath in it.",
  "erg_language_server": "https://github.com/erg-lang/erg#flags ELS ELS (erg-language-server) is a\nlanguage server for the Erg programming language. erg-language-server\ncan be installed via `cargo` and used as follows:\n\n``` sh\ncargo install erg --features els\nerg --language-server\n```",
  "esbonio": "https://github.com/swyddfa/esbonio Esbonio is a language server for\n[Sphinx](https://www.sphinx-doc.org/en/master/) documentation projects.\nThe language server can be installed via pip\n\n    pip install esbonio\n\nSince Sphinx is highly extensible you will get best results if you\ninstall the language server in the same Python environment as the one\nused to build your documentation. To ensure that the correct Python\nenvironment is picked up, you can either launch `nvim` with the correct\nenvironment activated.\n\n    source env/bin/activate\n    nvim\n\nOr you can modify the default `cmd` to include the full path to the\nPython interpreter.\n\n``` lua\nvim.lsp.config('esbonio', {\n  cmd = { '/path/to/virtualenv/bin/python', '-m', 'esbonio' }\n})\n```\n\nEsbonio supports a number of config values passed as `init_options` on\nstartup, for example.\n\n``` lua\nvim.lsp.config('esbonio', {\n  init_options = {\n    server = {\n      logLevel = \"debug\"\n    },\n    sphinx = {\n      confDir = \"/path/to/docs\",\n      srcDir = \"${confDir}/../docs-src\"\n    }\n})\n```\n\nA full list and explanation of the available options can be found\n[here](https://docs.esbon.io/en/esbonio-language-server-v0.16.4/lsp/getting-started.html?editor=neovim-lspconfig#configuration)",
  "eslint": "",
  "expert": "https://github.com/elixir-lang/expert Expert is the official language\nserver implementation for the Elixir programming language. 'root_dir' is\nchosen like this: if two or more directories containing `mix.exs` were\nfound when searching directories upward, the second one (higher up) is\nchosen, with the assumption that it is the root of an umbrella app.\nOtherwise the directory containing the single mix.exs that was found is\nchosen.",
  "facility_language_server": "https://github.com/FacilityApi/FacilityLanguageServer Facility language\nserver protocol (LSP) support.",
  "fennel_language_server": "https://github.com/rydesun/fennel-language-server Fennel language server\nprotocol (LSP) support.",
  "fennel_ls": "https://sr.ht/\\~xerool/fennel-ls/ A language server for fennel.\nfennel-ls is configured using the closest file to your working directory\nnamed `flsproject.fnl`. All fennel-ls configuration options [can be\nfound\nhere](https://git.sr.ht/~xerool/fennel-ls/tree/HEAD/docs/manual.md#configuration).",
  "fish_lsp": "https://github.com/ndonfris/fish-lsp A Language Server Protocol (LSP)\ntailored for the fish shell. This project aims to enhance the coding\nexperience for fish, by introducing a suite of intelligent features like\nauto-completion, scope aware symbol analysis, per-token hover\ngeneration, and many others. [homepage](https://www.fish-lsp.dev/)",
  "flow": "https://flow.org/ https://github.com/facebook/flow See below for how to\nsetup Flow itself. https://flow.org/en/docs/install/ See below for lsp\ncommand options.\n\n``` sh\nnpx flow lsp --help\n```",
  "flux_lsp": "https://github.com/influxdata/flux-lsp `flux-lsp` can be installed via\n`cargo`:\n\n``` sh\ncargo install --git https://github.com/influxdata/flux-lsp\n```",
  "foam_ls": "https://github.com/FoamScience/foam-language-server\n`foam-language-server` can be installed via `npm`\n\n``` sh\nnpm install -g foam-language-server\n```",
  "fortls": "https://fortls.fortran-lang.org/index.html fortls is a Fortran Language\nServer, the server can be installed via pip\n\n``` sh\npip install fortls\n```\n\nSettings to the server can be passed either through the `cmd` option or\nthrough a local configuration file e.g. `.fortls`. For more information\nsee the `fortls`\n[documentation](https://fortls.fortran-lang.org/options.html).",
  "fsautocomplete": "https://github.com/fsharp/FsAutoComplete Language Server for F# provided\nby FsAutoComplete (FSAC). FsAutoComplete requires the\n[dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. The\npreferred way to install FsAutoComplete is with\n`dotnet tool install --global fsautocomplete`. Instructions to compile\nfrom source are found on the main\n[repository](https://github.com/fsharp/FsAutoComplete). You may also\nneed to configure the filetype as Vim defaults to Forth for `*.fs`\nfiles: `autocmd BufNewFile,BufRead *.fs,*.fsx,*.fsi set filetype=fsharp`\nThis is automatically done by plugins such as\n[PhilT/vim-fsharp](https://github.com/PhilT/vim-fsharp),\n[fsharp/vim-fsharp](https://github.com/fsharp/vim-fsharp), and\n[adelarsq/neofsharp.vim](https://github.com/adelarsq/neofsharp.vim).",
  "fsharp_language_server": "F# Language Server https://github.com/faldor20/fsharp-language-server An\nimplementation of the language server protocol using the F# Compiler\nService. Build the project from source and override the command path to\nlocation of DLL. If filetype determination is not already performed by\nan available plugin\n([PhilT/vim-fsharp](https://github.com/PhilT/vim-fsharp),\n[fsharp/vim-fsharp](https://github.com/fsharp/vim-fsharp), and\n[adelarsq/neofsharp.vim](https://github.com/adelarsq/neofsharp.vim). ),\nthen the following must be added to initialization configuration:\n`autocmd BufNewFile,BufRead *.fs,*.fsx,*.fsi set filetype=fsharp`",
  "fstar": "https://github.com/FStarLang/FStar LSP support is included in FStar.\nMake sure `fstar.exe` is in your PATH.",
  "futhark_lsp": "https://github.com/diku-dk/futhark Futhark Language Server This language\nserver comes with the futhark compiler and is run with the command\n\n    futhark lsp",
  "gdscript": "https://github.com/godotengine/godot Language server for GDScript, used\nby Godot Engine.",
  "gdshader_lsp": "https://github.com/godofavacyn/gdshader-lsp A language server for the\nGodot Shading language.",
  "gh_actions_ls": "https://github.com/lttb/gh-actions-language-server Language server for\nGitHub Actions. The projects [forgejo](https://forgejo.org/) and\n[gitea](https://about.gitea.com/) design their actions to be as\ncompatible to github as possible with only [a few\ndifferences](https://docs.gitea.com/usage/actions/comparison#unsupported-workflows-syntax)\nbetween the systems. The `gh_actions_ls` is therefore enabled for those\n`yaml` files as well. The `gh-actions-language-server` can be installed\nvia `npm`:\n\n``` sh\nnpm install -g gh-actions-language-server\n```",
  "ghcide": "https://github.com/digital-asset/ghcide A library for building Haskell\nIDE tooling. \"ghcide\" isn't for end users now. Use\n\"haskell-language-server\" instead of \"ghcide\".",
  "ghdl_ls": "https://github.com/ghdl/ghdl-language-server A language server for VHDL,\nusing ghdl as its backend. `ghdl-ls` is part of pyghdl, for installation\ninstructions see [the upstream\nREADME](https://github.com/ghdl/ghdl/tree/master/pyGHDL/lsp).",
  "ginko_ls": "Language servers can be used in many editors, such as Visual Studio\nCode, Emacs or Vim Install `ginko_ls` from\nhttps://github.com/Schottkyc137/ginko and add it to path `ginko_ls`\ndoesn't require any configuration.",
  "gitlab_ci_ls": "https://github.com/alesbrelih/gitlab-ci-ls Language Server for Gitlab CI\n`gitlab-ci-ls` can be installed via cargo: cargo install gitlab-ci-ls",
  "gitlab_duo": "GitLab Duo Language Server Configuration for Neovim\nhttps://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp The GitLab\nLSP enables any editor or IDE to integrate with GitLab Duo for\nAI-powered code suggestions via the Language Server Protocol.\nPrerequisites: - Node.js and npm installed - GitLab account with Duo Pro\nlicense - Internet connection for OAuth device flow Setup: 1. Run\n:LspGitLabDuoSignIn to start OAuth authentication 2. Follow the browser\nprompts to authorize 3. Enable inline completion in LspAttach event (see\nexample below) Inline Completion Example:\n\n``` lua\nvim.api.nvim_create_autocmd('LspAttach', {\n  callback = function(args)\n    local bufnr = args.buf\n    local client = assert(vim.lsp.get_client_by_id(args.data.client_id))\n    if vim.lsp.inline_completion and\n       client:supports_method(vim.lsp.protocol.Methods.textDocument_inlineCompletion, bufnr) then\n      vim.lsp.inline_completion.enable(true, { bufnr = bufnr })\n      -- Tab to accept suggestion\n      vim.keymap.set('i', '<Tab>', function()\n        if vim.lsp.inline_completion.is_visible() then\n          return vim.lsp.inline_completion.accept()\n        else\n          return '<Tab>'\n        end\n      end, { expr = true, buffer = bufnr, desc = 'GitLab Duo: Accept suggestion' })\n      -- Alt/Option+[ for previous suggestion\n      vim.keymap.set('i', '<M-[>', vim.lsp.inline_completion.select_prev,\n        { buffer = bufnr, desc = 'GitLab Duo: Previous suggestion' })\n      -- Alt/Option+] for next suggestion\n      vim.keymap.set('i', '<M-]>', vim.lsp.inline_completion.select_next,\n        { buffer = bufnr, desc = 'GitLab Duo: Next suggestion' })\n    end\n  end\n})\n```",
  "glasgow": "https://github.com/nolanderc/glasgow Provides language features for WGSL\n(WebGPU Shading Language): - Completions: - Local\nfunctions/variables/types. - Fields and swizzles. - Builtin types and\nfunctions (`dot`, `reflect`, `textureSample`, `vec3`, `mat4x2`, etc.) -\nHover Documentation: - Function signatures. - Variable types. - Includes\nbuiltin types and functions. Text is taken from the WGSL\nspecification. - Goto Definition - Find all References - Rename -\nFormatter `glasgow` can be installed via `cargo`:\n\n``` sh\ncargo install glasgow\n```",
  "gleam": "https://github.com/gleam-lang/gleam A language server for Gleam\nProgramming Language. It comes with the Gleam compiler, for installation\nsee: [Installing Gleam](https://gleam.run/getting-started/installing/)",
  "glint": "https://github.com/typed-ember/glint\nhttps://typed-ember.gitbook.io/glint/ `glint-language-server` is\ninstalled when adding `@glint/core` to your project's devDependencies:\n\\`\\``sh npm install @glint/core --save-dev yarn add -D @glint/core This configuration uses the local installation of`glint-language-server`(found in the`node_modules`directory of your project). To use a global installation of`glint-language-server`, set the`init_options.glint.useGlobal`to`true\\`.\nvim.lsp.config('glint', { init_options = { glint = { useGlobal = true,\n}, }, })",
  "glsl_analyzer": "https://github.com/nolanderc/glsl_analyzer Language server for GLSL",
  "glslls": "https://github.com/svenstaro/glsl-language-server Language server\nimplementation for GLSL `glslls` can be compiled and installed manually,\nor, if your distribution has access to the AUR, via the\n`glsl-language-server` AUR package",
  "gn_language_server": "https://github.com/google/gn-language-server A language server for GN,\nthe build configuration language used in Chromium, Fuchsia, and other\nprojects.",
  "gnls": "https://github.com/microsoft/gnls Microsoft's language server for GN\nbuild files. Assuming there is a `gnls` script somewhere in your\n`$PATH`, containing for example:\n\n``` shell\nGNLS_SRC_DIR=</path/to/gnls>\nexec node ${GNLS_SRC_DIR}/build/server.js $@\n```",
  "golangci_lint_ls": "Combination of both lint server and client\nhttps://github.com/nametake/golangci-lint-langserver\nhttps://github.com/golangci/golangci-lint Installation of binaries\nneeded is done via\n\n    go install github.com/nametake/golangci-lint-langserver@latest\n    go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest",
  "gopls": "https://github.com/golang/tools/tree/master/gopls Google's lsp server\nfor golang.",
  "gradle_ls": "https://github.com/microsoft/vscode-gradle Microsoft's lsp server for\ngradle files If you're setting this up manually, build vscode-gradle\nusing `./gradlew installDist` and point `cmd` to the\n`gradle-language-server` generated in the build directory",
  "grammarly": "https://github.com/znck/grammarly `grammarly-languageserver` can be\ninstalled via `npm`:\n\n``` sh\nnpm i -g grammarly-languageserver\n```\n\nWARNING: Since this language server uses Grammarly's API, any document\nyou open with it running is shared with them. Please evaluate their\n[privacy policy](https://www.grammarly.com/privacy-policy) before using\nthis.",
  "graphql": "https://github.com/graphql/graphiql/tree/main/packages/graphql-language-service-cli\n`graphql-lsp` can be installed via `npm`:\n\n``` sh\nnpm install -g graphql-language-service-cli\n```\n\nNote that you must also have [the graphql\npackage](https://github.com/graphql/graphql-js) installed within your\nproject and create a [GraphQL config\nfile](https://the-guild.dev/graphql/config/docs).",
  "groovyls": "https://github.com/prominic/groovy-language-server.git Requirements: -\nLinux/macOS (for now) - Java 11+ `groovyls` can be installed by\nfollowing the instructions\n[here](https://github.com/prominic/groovy-language-server.git#build). If\nyou have installed groovy language server, you can set the `cmd` custom\npath as follow:\n\n``` lua\nvim.lsp.config('groovyls', {\n    -- Unix\n    cmd = { \"java\", \"-jar\", \"path/to/groovyls/groovy-language-server-all.jar\" },\n    ...\n})\n```",
  "guile_ls": "https://codeberg.org/rgherdt/scheme-lsp-server The recommended way is to\ninstall guile-lsp-server is using Guix. Unfortunately it is still not\navailable at the official Guix channels, but you can use the provided\nchannel guix.scm in the repo:\n\n``` sh\nguix package -f guix.scm\n```\n\nCheckout the repo for more info. Note: This LSP will start on\n`scheme.guile` filetype. You can set this file type using\n`:help modeline` or adding https://gitlab.com/HiPhish/guile.vim to your\nplugins to automatically set it.",
  "harper_ls": "https://github.com/automattic/harper The language server for Harper, the\nslim, clean language checker for developers. See our\n[documentation](https://writewithharper.com/docs/integrations/neovim)\nfor more information on settings. In short, they should look something\nlike this:\n\n``` lua\nvim.lsp.config('harper_ls', {\n  settings = {\n    [\"harper-ls\"] = {\n      userDictPath = \"~/dict.txt\"\n    }\n  },\n})\n```",
  "hdl_checker": "https://github.com/suoto/hdl_checker Language server for hdl-checker.\nInstall using: `pip install hdl-checker --upgrade`",
  "helm_ls": "https://github.com/mrjosh/helm-ls Helm Language server. (This LSP is in\nearly development) `helm Language server` can be installed by following\nthe instructions [here](https://github.com/mrjosh/helm-ls). The default\n`cmd` assumes that the `helm_ls` binary can be found in `$PATH`. If need\nHelm file highlight use [vim-helm](https://github.com/towolf/vim-helm)\nplugin.",
  "herb_ls": "https://www.npmjs.com/package/@herb-tools/language-server\nhttps://github.com/marcoroth/herb HTML+ERB (HTML + Embedded Ruby)\nPowerful and seamless HTML-aware ERB parsing and tooling. Herb is\ndesigned from the ground up to deeply understand `.html.erb` files,\npreserving both HTML and embedded Ruby structure without losing any\ndetails. `herb-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g @herb-tools/language-server\n```\n\nor via `yarn`:\n\n``` sh\nyarn global add @herb-tools/language-server\n```",
  "hhvm": "Language server for programs written in Hack https://hhvm.com/\nhttps://github.com/facebook/hhvm See below for how to setup HHVM &\ntypechecker: https://docs.hhvm.com/hhvm/getting-started/getting-started",
  "hie": "https://github.com/haskell/haskell-ide-engine the following init_options\nare supported (see\nhttps://github.com/haskell/haskell-ide-engine#configuration):\n\n``` lua\ninit_options = {\n  languageServerHaskell = {\n    hlintOn = bool;\n    maxNumberOfProblems = number;\n    diagnosticsDebounceDuration = number;\n    liquidOn = bool (default false);\n    completionSnippetsOn = bool (default true);\n    formatOnImportOn = bool (default true);\n    formattingProvider = string (default \"brittany\", alternate \"floskell\");\n  }\n}\n```",
  "hlasm": "`hlasm_language_server` is a language server for the High Level\nAssembler language used on IBM SystemZ mainframes. To learn how to\nconfigure the HLASM language server, see the [HLASM Language Support\ndocumentation](https://github.com/eclipse-che4z/che-che4z-lsp-for-hlasm).",
  "hls": "https://github.com/haskell/haskell-language-server Haskell Language\nServer If you are using HLS 1.9.0.0, enable the language server to\nlaunch on Cabal files as well:\n\n``` lua\nvim.lsp.config('hls', {\n  filetypes = { 'haskell', 'lhaskell', 'cabal' },\n})\n```",
  "home_assistant": "https://github.com/keesschollaart81/vscode-home-assistant\n`vscode-home-assistant` can be installed via from source or by\ndownloading and extracting the VSCode \"Home Assistant Config Helper\"\nextension `vscode-home-assistant` is a language server for Home\nAssistant ported from the VSCode \"Home Assistant Config Helper\"\nextension.",
  "hoon_ls": "https://github.com/urbit/hoon-language-server A language server for\nHoon. The language server can be installed via\n`npm install -g @hoon-language-server` Start a fake \\~zod with\n`urbit -F zod`. Start the language server at the Urbit Dojo prompt with:\n`|start %language-server`",
  "html": "https://github.com/hrsh7th/vscode-langservers-extracted\n`vscode-html-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g vscode-langservers-extracted\n```\n\nNeovim does not currently include built-in snippets.\n`vscode-html-language-server` only provides completions when snippet\nsupport is enabled. To enable completion, install a snippet plugin and\nadd the following override to your language client capabilities during\nsetup. The code-formatting feature of the lsp can be controlled with the\n`provideFormatter` option.\n\n``` lua\n--Enable (broadcasting) snippet capability for completion\nlocal capabilities = vim.lsp.protocol.make_client_capabilities()\ncapabilities.textDocument.completion.completionItem.snippetSupport = true\nvim.lsp.config('html', {\n  capabilities = capabilities,\n})\n```",
  "htmx": "https://github.com/ThePrimeagen/htmx-lsp `htmx-lsp` can be installed via\n`cargo`:\n\n``` sh\ncargo install htmx-lsp\n```\n\nLsp is still very much work in progress and experimental. Use at your\nown risk.",
  "hydra_lsp": "https://github.com/Retsediv/hydra-lsp LSP for Hydra Python package\nconfig files.",
  "hylo_ls": "https://github.com/hylo-lang/hylo-language-server A language server for\nthe Hylo programming language.",
  "hyprls": "https://github.com/hyprland-community/hyprls `hyprls` can be installed\nvia `go`:\n\n``` sh\ngo install github.com/hyprland-community/hyprls/cmd/hyprls@latest\n```",
  "idris2_lsp": "https://github.com/idris-community/idris2-lsp The Idris 2 language\nserver. Plugins for the Idris 2 filetype include\n[Idris2-Vim](https://github.com/edwinb/idris2-vim) (fewer features,\nstable) and [Nvim-Idris2](https://github.com/ShinKage/nvim-idris2)\n(cutting-edge, experimental). Idris2-Lsp requires a build of Idris 2\nthat includes the \"Idris 2 API\" package. Package managers with known\nsupport for this build include the\n[AUR](https://aur.archlinux.org/packages/idris2/) and\n[Homebrew](https://formulae.brew.sh/formula/idris2#default). If your\npackage manager does not support the Idris 2 API, you will need to build\nIdris 2 from source. Refer to the [the Idris 2 installation\ninstructions](https://github.com/idris-lang/Idris2/blob/main/INSTALL.md)\nfor details. Steps 5 and 8 are listed as \"optional\" in that guide, but\nthey are necessary in order to make the Idris 2 API available. You need\nto install a version of Idris2-Lsp that is compatible with your version\nof Idris 2. There should be a branch corresponding to every released\nIdris 2 version after v0.4.0. Use the latest commit on that branch. For\nexample, if you have Idris v0.5.1, you should use the v0.5.1 branch of\nIdris2-Lsp. If your Idris 2 version is newer than the newest Idris2-Lsp\nbranch, use the latest commit on the `master` branch, and set a reminder\nto check the Idris2-Lsp repo for the release of a compatible versioned\nbranch.",
  "intelephense": "https://intelephense.com/ `intelephense` can be installed via `npm`:\n\n``` sh\nnpm install -g intelephense\n```\n\n``` lua\n-- See https://github.com/bmewburn/intelephense-docs/blob/master/installation.md#initialisation-options\ninit_options = {\n  storagePath = …, -- Optional absolute path to storage dir. Defaults to os.tmpdir().\n  globalStoragePath = …, -- Optional absolute path to a global storage dir. Defaults to os.homedir().\n  licenceKey = …, -- Optional licence key or absolute path to a text file containing the licence key.\n  clearCache = …, -- Optional flag to clear server state. State can also be cleared by deleting {storagePath}/intelephense\n}\n-- See https://github.com/bmewburn/intelephense-docs\nsettings = {\n  intelephense = {\n    files = {\n      maxSize = 1000000;\n    };\n  };\n}\n```",
  "janet_lsp": "https://github.com/CFiggers/janet-lsp A Language Server Protocol\nimplementation for Janet.",
  "java_language_server": "https://github.com/georgewfraser/java-language-server Java language\nserver Point `cmd` to `lang_server_linux.sh` or the equivalent script\nfor macOS/Windows provided by java-language-server",
  "jdtls": "https://projects.eclipse.org/projects/eclipse.jdt.ls Language server for\nJava. IMPORTANT: If you want all the features jdtls has to offer,\n[nvim-jdtls](https://github.com/mfussenegger/nvim-jdtls) is highly\nrecommended. If all you need is diagnostics, completion, imports, gotos\nand formatting and some code actions you can keep reading here. For\nmanual installation you can download precompiled binaries from the\n[official downloads\nsite](http://download.eclipse.org/jdtls/snapshots/?d) and ensure that\nthe `PATH` variable contains the `bin` directory of the extracted\narchive.\n\n``` lua\n  -- init.lua\n  vim.lsp.enable('jdtls')\n```\n\nYou can also pass extra custom jvm arguments with the JDTLS_JVM_ARGS\nenvironment variable as a space separated list of arguments, that will\nbe converted to multiple --jvm-arg=`<param>`{=html} args when passed to\nthe jdtls script. This will allow for example tweaking the jvm arguments\nor integration with external tools like lombok:\n\n``` sh\nexport JDTLS_JVM_ARGS=\"-javaagent:$HOME/.local/share/java/lombok.jar\"\n```\n\nFor automatic installation you can use the following unofficial\ninstallers/launchers under your own risk: -\n[jdtls-launcher](https://github.com/eruizc-dev/jdtls-launcher) (Includes\nlombok support by default)\n`lua       -- init.lua       vim.lsp.config('jdtls', { cmd = { 'jdtls' } })`",
  "jedi_language_server": "https://github.com/pappasam/jedi-language-server `jedi-language-server`,\na language server for Python, built on top of jedi",
  "jinja_lsp": "jinja-lsp enhances minijinja development experience by providing\nHelix/Nvim users with advanced features such as autocomplete, syntax\nhighlighting, hover, goto definition, code actions and linting. The file\ntypes are not detected automatically, you can register them manually\n(see below) or override the filetypes:\n\n``` lua\nvim.filetype.add {\n  extension = {\n    jinja = 'jinja',\n    jinja2 = 'jinja',\n    j2 = 'jinja',\n  },\n}\n```",
  "jqls": "https://github.com/wader/jq-lsp Language server for jq, written using\nGo. You can install the server easily using go install:\n\n``` sh\n# install directly\ngo install github.com/wader/jq-lsp@master\n# copy binary to $PATH\ncp $(go env GOPATH)/bin/jq-lsp /usr/local/bin\n```\n\nNote: To activate properly nvim needs to know the jq filetype. You can\nadd it via:\n\n``` lua\nvim.cmd([[au BufRead,BufNewFile *.jq setfiletype jq]])\n```",
  "jsonls": "https://github.com/hrsh7th/vscode-langservers-extracted\nvscode-json-language-server, a language server for JSON and JSON schema\n`vscode-json-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g vscode-langservers-extracted\n```\n\n`vscode-json-language-server` only provides completions when snippet\nsupport is enabled. If you use Neovim older than v0.10 you need to\nenable completion, install a snippet plugin and add the following\noverride to your language client capabilities during setup.\n\n``` lua\n--Enable (broadcasting) snippet capability for completion\nlocal capabilities = vim.lsp.protocol.make_client_capabilities()\ncapabilities.textDocument.completion.completionItem.snippetSupport = true\nvim.lsp.config('jsonls', {\n  capabilities = capabilities,\n})\n```",
  "jsonnet_ls": "",
  "julials": "https://github.com/julia-vscode/julia-vscode LanguageServer.jl,\nSymbolServer.jl and StaticLint.jl can be installed with `julia` and\n`Pkg`:\n\n``` sh\njulia --project=~/.julia/environments/nvim-lspconfig -e 'using Pkg; Pkg.add(\"LanguageServer\"); Pkg.add(\"SymbolServer\"); Pkg.add(\"StaticLint\")'\n```\n\nwhere `~/.julia/environments/nvim-lspconfig` is the location where the\ndefault configuration expects LanguageServer.jl, SymbolServer.jl and\nStaticLint.jl to be installed. To update an existing install, use the\nfollowing command:\n\n``` sh\njulia --project=~/.julia/environments/nvim-lspconfig -e 'using Pkg; Pkg.update()'\n```\n\nNote: In order to have LanguageServer.jl pick up installed packages or\ndependencies in a Julia project, you must make sure that the project is\ninstantiated:\n\n``` sh\njulia --project=/path/to/my/project -e 'using Pkg; Pkg.instantiate()'\n```\n\nNote: The julia programming language searches for global environments\nwithin the `environments/` folder of `$JULIA_DEPOT_PATH` entries. By\ndefault this simply `~/.julia/environments`",
  "just": "https://github.com/terror/just-lsp `just-lsp` is an LSP for just built\non top of the tree-sitter-just parser.",
  "kcl": "https://github.com/kcl-lang/kcl.nvim Language server for the KCL\nconfiguration and policy language.",
  "koka": "https://koka-lang.github.io/koka/doc/index.html Koka is a functional\nprogramming language with effect types and handlers.",
  "kotlin_language_server": "A kotlin language server which was developed for internal usage and\nreleased afterwards. Maintaining is not done by the original author, but\nby fwcd. It is built via gradle and developed on github. Source and\nadditional description: https://github.com/fwcd/kotlin-language-server\nThis server requires vim to be aware of the kotlin-filetype. You could\nrefer for this capability to: https://github.com/udalov/kotlin-vim\n(recommended) Note that there is no LICENSE specified yet. For faster\nstartup, you can setup caching by specifying a storagePath in the\ninit_options. The default is your home directory.",
  "kotlin_lsp": "",
  "kulala_ls": "https://github.com/mistweaverco/kulala-ls A minimal language server for\nHTTP syntax.",
  "laravel_ls": "https://github.com/laravel-ls/laravel-ls `laravel-ls`, language server\nfor laravel The default `cmd` assumes that the `laravel-ls` binary can\nbe found in `$PATH`.",
  "lean3ls": "https://github.com/leanprover/lean-client-js/tree/master/lean-language-server\nLean installation instructions can be found\n[here](https://leanprover-community.github.io/get_started.html#regular-install).\nOnce Lean is installed, you can install the Lean 3 language server by\nrunning\n\n``` sh\nnpm install -g lean-language-server\n```\n\nNote: that if you're using\n[lean.nvim](https://github.com/Julian/lean.nvim), that plugin fully\nhandles the setup of the Lean language server, and you shouldn't set up\n`lean3ls` both with it and `lspconfig`.",
  "lelwel_ls": "https://github.com/0x2a-42/lelwel Language server for lelwel grammars.\nYou can install `lelwel-ls` via cargo:\n\n``` sh\ncargo install --features=\"lsp\" lelwel\n```",
  "lemminx": "https://github.com/eclipse/lemminx The easiest way to install the server\nis to get a binary from\nhttps://github.com/redhat-developer/vscode-xml/releases and place it on\nyour PATH. NOTE to macOS users: Binaries from unidentified developers\nare blocked by default. If you trust the downloaded binary, run it once,\ncancel the prompt, then remove the binary from Gatekeeper quarantine\nwith `xattr -d com.apple.quarantine lemminx`. It should now run without\nbeing blocked.",
  "lexical": "https://github.com/lexical-lsp/lexical Lexical is a next-generation\nlanguage server for the Elixir programming language. To install from\nsource, follow the [Detailed Installation\nInstructions](https://github.com/lexical-lsp/lexical/blob/main/pages/installation.md).\nEnsure to point `cmd` to the generated\n`_build/dev/package/lexical/start_lexical.sh` executable.",
  "lsp_ai": "https://github.com/SilasMarvin/lsp-ai LSP-AI is an open source language\nserver that serves as a backend for AI-powered functionality in your\nfavorite code editors. It offers features like in-editor chatting with\nLLMs and code completions. You will need to provide configuration for\nthe inference backends and models you want to use, as well as configure\ncompletion/code actions. See the [wiki\ndocs](https://github.com/SilasMarvin/lsp-ai/wiki/Configuration) and\n[examples](https://github.com/SilasMarvin/lsp-ai/blob/main/examples/nvim)\nfor more information.",
  "ltex": "https://github.com/valentjn/ltex-ls LTeX Language Server: LSP language\nserver for LanguageTool 🔍✔️ with support for LaTeX 🎓, Markdown 📝, and\nothers To install, download the latest\n[release](https://github.com/valentjn/ltex-ls/releases) and ensure\n`ltex-ls` is on your path. This server accepts configuration via the\n`settings` key.\n\n``` lua\n  settings = {\n        ltex = {\n            language = \"en-GB\",\n        },\n    },\n```\n\nTo support org files or R sweave, users can define a custom filetype\nautocommand (or use a plugin which defines these filetypes):\n\n``` lua\nvim.cmd [[ autocmd BufRead,BufNewFile *.org set filetype=org ]]\n```",
  "ltex_plus": "https://github.com/ltex-plus/ltex-ls-plus LTeX Language Server: LSP\nlanguage server for LanguageTool 🔍✔️ with support for LaTeX 🎓,\nMarkdown 📝, and others To install, download the latest\n[release](https://github.com/ltex-plus/ltex-ls-plus) and ensure\n`ltex-ls-plus` is on your path. This server accepts configuration via\nthe `settings` key.\n\n``` lua\n  settings = {\n    ltex = {\n      language = \"en-GB\",\n    },\n  },\n```\n\nTo support org files or R sweave, users can define a custom filetype\nautocommand (or use a plugin which defines these filetypes):\n\n``` lua\nvim.cmd [[ autocmd BufRead,BufNewFile *.org set filetype=org ]]\n```",
  "lua_ls": "https://github.com/luals/lua-language-server Lua language server.\n`lua-language-server` can be installed by following the instructions\n[here](https://luals.github.io/#neovim-install). The default `cmd`\nassumes that the `lua-language-server` binary can be found in `$PATH`.\nIf you primarily use `lua-language-server` for Neovim, and want to\nprovide completions, analysis, and location handling for plugins on\nruntime path, you can use the following settings.\n\n``` lua\nvim.lsp.config('lua_ls', {\n  on_init = function(client)\n    if client.workspace_folders then\n      local path = client.workspace_folders[1].name\n      if\n        path ~= vim.fn.stdpath('config')\n        and (vim.uv.fs_stat(path .. '/.luarc.json') or vim.uv.fs_stat(path .. '/.luarc.jsonc'))\n      then\n        return\n      end\n    end\n    client.config.settings.Lua = vim.tbl_deep_extend('force', client.config.settings.Lua, {\n      runtime = {\n        -- Tell the language server which version of Lua you're using (most\n        -- likely LuaJIT in the case of Neovim)\n        version = 'LuaJIT',\n        -- Tell the language server how to find Lua modules same way as Neovim\n        -- (see `:h lua-module-load`)\n        path = {\n          'lua/?.lua',\n          'lua/?/init.lua',\n        },\n      },\n      -- Make the server aware of Neovim runtime files\n      workspace = {\n        checkThirdParty = false,\n        library = {\n          vim.env.VIMRUNTIME,\n          -- Depending on the usage, you might want to add additional paths\n          -- here.\n          -- '${3rd}/luv/library',\n          -- '${3rd}/busted/library',\n        },\n        -- Or pull in all of 'runtimepath'.\n        -- NOTE: this is a lot slower and will cause issues when working on\n        -- your own configuration.\n        -- See https://github.com/neovim/nvim-lspconfig/issues/3189\n        -- library = vim.api.nvim_get_runtime_file('', true),\n      },\n    })\n  end,\n  settings = {\n    Lua = {},\n  },\n})\n```\n\nSee `lua-language-server`'s\n[documentation](https://luals.github.io/wiki/settings/) for an\nexplanation of the above fields: \\*\n[Lua.runtime.path](https://luals.github.io/wiki/settings/#runtimepath)\n\\*\n[Lua.workspace.library](https://luals.github.io/wiki/settings/#workspacelibrary)",
  "luau_lsp": "https://github.com/JohnnyMorganz/luau-lsp Language server for the\n[Luau](https://luau-lang.org/) language. `luau-lsp` can be installed by\ndownloading one of the release assets available at\nhttps://github.com/JohnnyMorganz/luau-lsp. You might also have to set up\nautomatic filetype detection for Luau files, for example like so:\n\n``` vim\nautocmd BufRead,BufNewFile *.luau setf luau\n```",
  "lwc_ls": "https://github.com/forcedotcom/lightning-language-server/ Language\nserver for Lightning Web Components. For manual installation, utilize\nthe official [NPM\npackage](https://www.npmjs.com/package/@salesforce/lwc-language-server).\nThen, configure `cmd` to run the Node script at the unpacked location:\n\n``` lua\nvim.lsp.config('lwc_ls', {\n  cmd = {\n    'node',\n    '/path/to/node_modules/@salesforce/lwc-language-server/bin/lwc-language-server.js',\n    '--stdio'\n  }\n})\n```",
  "m68k": "https://github.com/grahambates/m68k-lsp Language server for Motorola\n68000 family assembly `m68k-lsp-server` can be installed via `npm`:\n\n``` sh\nnpm install -g m68k-lsp-server\n```\n\nEnsure you are using the 68k asm syntax variant in Neovim.\n\n``` lua\nvim.g.asmsyntax = 'asm68k'\n```",
  "markdown_oxide": "https://github.com/Feel-ix-343/markdown-oxide Editor Agnostic PKM: you\nbring the text editor and we bring the PKM. Inspired by and compatible\nwith Obsidian. Check the readme to see how to properly setup.",
  "marko-js": "https://github.com/marko-js/language-server Using the Language Server\nProtocol to improve Marko's developer experience. Can be installed via\nnpm:\n\n    npm i -g @marko/language-server",
  "marksman": "https://github.com/artempyanykh/marksman Marksman is a Markdown LSP\nserver providing completion, cross-references, diagnostics, and more.\nMarksman works on MacOS, Linux, and Windows and is distributed as a\nself-contained binary for each OS. Pre-built binaries can be downloaded\nfrom https://github.com/artempyanykh/marksman/releases",
  "matlab_ls": "https://github.com/mathworks/MATLAB-language-server MATLAB® language\nserver implements the Microsoft® Language Server Protocol for the MATLAB\nlanguage. Make sure to set `MATLAB.installPath` to your MATLAB path,\ne.g.:\n\n``` lua\nsettings = {\n  MATLAB = {\n    ...\n    installPath = '/usr/local/MATLAB/R2023a',\n    ...\n  },\n},\n```",
  "mdx_analyzer": "https://github.com/mdx-js/mdx-analyzer `mdx-analyzer`, a language server\nfor MDX",
  "mesonlsp": "https://github.com/JCWasmx86/mesonlsp An unofficial, unendorsed language\nserver for meson written in C++",
  "metals": "https://scalameta.org/metals/ Scala language server with rich IDE\nfeatures. See full instructions in the Metals documentation:\nhttps://scalameta.org/metals/docs/editors/vim#using-an-alternative-lsp-client\nNote: that if you're using\n[nvim-metals](https://github.com/scalameta/nvim-metals), that plugin\nfully handles the setup and installation of Metals, and you shouldn't\nset up Metals both with it and `lspconfig`. To install Metals, make sure\nto have [coursier](https://get-coursier.io/docs/cli-installation)\ninstalled, and once you do you can install the latest Metals with\n`cs install metals`.",
  "millet": "https://github.com/azdavis/millet Millet, a language server for Standard\nML To use with nvim: 1. Install a Rust toolchain: https://rustup.rs 2.\nClone the repo 3. Run `cargo build --release --bin millet-ls` 4. Move\n`target/release/millet-ls` to somewhere on your \\$PATH as `millet`",
  "mint": "https://www.mint-lang.com Install Mint using the\n[instructions](https://www.mint-lang.com/install). The language server\nis included since version 0.12.0.",
  "mlir_lsp_server": "https://mlir.llvm.org/docs/Tools/MLIRLSP/#mlir-lsp-language-server--mlir-lsp-server=\nThe Language Server for the LLVM MLIR language `mlir-lsp-server` can be\ninstalled at the llvm-project repository\n(https://github.com/llvm/llvm-project)",
  "mlir_pdll_lsp_server": "https://mlir.llvm.org/docs/Tools/MLIRLSP/#pdll-lsp-language-server--mlir-pdll-lsp-server\nThe Language Server for the LLVM PDLL language `mlir-pdll-lsp-server`\ncan be installed at the llvm-project repository\n(https://github.com/llvm/llvm-project)",
  "mm0_ls": "https://github.com/digama0/mm0 Language Server for the metamath-zero\ntheorem prover. Requires\n[mm0-rs](https://github.com/digama0/mm0/tree/master/mm0-rs) to be\ninstalled and available on the `PATH`.",
  "mojo": "https://github.com/modularml/mojo `mojo-lsp-server` can be installed\n[via Modular](https://developer.modular.com/download) Mojo is a new\nprogramming language that bridges the gap between research and\nproduction by combining Python syntax and ecosystem with systems\nprogramming and metaprogramming features.",
  "motoko_lsp": "https://github.com/dfinity/vscode-motoko Language server for the Motoko\nprogramming language.",
  "move_analyzer": "https://github.com/move-language/move/tree/main/language/move-analyzer\nLanguage server for Move The `move-analyzer` can be installed by\nrunning:\n\n    cargo install --git https://github.com/move-language/move move-analyzer\n\nSee [`move-analyzer`'s\ndoc](https://github.com/move-language/move/blob/1b258a06e3c7d2bc9174578aac92cca3ac19de71/language/move-analyzer/editors/code/README.md#how-to-install)\nfor details.",
  "msbuild_project_tools_server": "https://github.com/tintoy/msbuild-project-tools-server/ MSBuild Project\nTools Server can be installed by following the README.MD on the above\nrepository. Example config:\n\n``` lua\nvim.lsp.config('msbuild_project_tools_server', {\n  cmd = {'dotnet', '/path/to/server/MSBuildProjectTools.LanguageServer.Host.dll'}\n})\n```\n\nThere's no builtin filetypes for msbuild files, would require some\nfiletype aliases:\n\n``` lua\nvim.filetype.add({\n  extension = {\n    props = 'msbuild',\n    tasks = 'msbuild',\n    targets = 'msbuild',\n  },\n  pattern = {\n    [ [[.*\\..*proj]] ] = 'msbuild',\n  },\n})\n```\n\nOptionally tell treesitter to treat `msbuild` as `xml` so you can get\nsyntax highlighting if you have the treesitter-xml-parser installed.\n\n``` lua\nvim.treesitter.language.register('xml', { 'msbuild' })\n```",
  "muon": "https://muon.build",
  "mutt_ls": "https://github.com/neomutt/mutt-language-server A language server for\n(neo)mutt's muttrc. It can be installed via pip.\n\n``` sh\npip install mutt-language-server\n```",
  "nelua_lsp": "",
  "neocmake": "https://github.com/neocmakelsp/neocmakelsp CMake LSP Implementation\nNeovim does not currently include built-in snippets. `neocmakelsp` only\nprovides completions when snippet support is enabled. To enable\ncompletion, install a snippet plugin and add the following override to\nyour language client capabilities during setup.\n\n``` lua\n--Enable (broadcasting) snippet capability for completion\nlocal capabilities = vim.lsp.protocol.make_client_capabilities()\ncapabilities.textDocument.completion.completionItem.snippetSupport = true\nvim.lsp.config('neocmake', {\n  capabilities = capabilities,\n})\n```",
  "nextflow_ls": "https://github.com/nextflow-io/language-server Requirements: - Java 17+\n`nextflow_ls` can be installed by following the instructions\n[here](https://github.com/nextflow-io/language-server#development). If\nyou have installed nextflow language server, you can set the `cmd`\ncustom path as follow:\n\n``` lua\nvim.lsp.config('nextflow_ls', {\n    cmd = { 'java', '-jar', 'nextflow-language-server-all.jar' },\n    filetypes = { 'nextflow' },\n    settings = {\n      nextflow = {\n        files = {\n          exclude = { '.git', '.nf-test', 'work' },\n        },\n      },\n    },\n})\n```",
  "nextls": "https://github.com/elixir-tools/next-ls **Please see the following\n[detailed\ninstructions](https://www.elixir-tools.dev/docs/next-ls/installation/)\nfor possible installation methods.**",
  "nginx_language_server": "https://pypi.org/project/nginx-language-server/ `nginx-language-server`\ncan be installed via pip:\n\n``` sh\npip install -U nginx-language-server\n```",
  "nickel_ls": "Nickel Language Server https://github.com/tweag/nickel `nls` can be\ninstalled with nix, or cargo, from the Nickel repository.\n\n``` sh\ngit clone https://github.com/tweag/nickel.git\n```\n\nNix:\n\n``` sh\ncd nickel\nnix-env -f . -i\n```\n\ncargo:\n\n``` sh\ncd nickel/lsp/nls\ncargo install --path .\n```\n\nIn order to have lspconfig detect Nickel filetypes (a prerequisite for\nautostarting a server), install the [Nickel vim\nplugin](https://github.com/nickel-lang/vim-nickel).",
  "nil_ls": "https://github.com/oxalica/nil A new language server for Nix Expression\nLanguage. If you are using Nix with Flakes support, run\n`nix profile install github:oxalica/nil` to install. Check the\nrepository README for more information. *See an example config at\nhttps://github.com/oxalica/nil/blob/main/dev/nvim-lsp.nix.*",
  "nim_langserver": "https://github.com/nim-lang/langserver `nim-langserver` can be installed\nvia the `nimble` package manager:\n\n``` sh\nnimble install nimlangserver\n```",
  "nimls": "https://github.com/PMunch/nimlsp `nimlsp` can be installed via the\n`nimble` package manager:\n\n``` sh\nnimble install nimlsp\n```",
  "nixd": "https://github.com/nix-community/nixd Nix language server, based on nix\nlibraries. If you are using Nix with Flakes support, run\n`nix profile install github:nix-community/nixd` to install. Check the\nrepository README for more information.",
  "nomad_lsp": "https://github.com/juliosueiras/nomad-lsp Written in Go, compilation is\nneeded for `nomad_lsp` to be used. Please see the [original\nrepository](https://github.com/juliosuieras/nomad-lsp). Add the\nexecutable to your system or vim PATH and it will be set to go. No\nconfiguration option is needed unless you choose not to add `nomad-lsp`\nexecutable to the PATH. You should know what you are doing if you choose\nso.\n\n``` lua\nvim.lsp.enable('nomad_lsp')\n```\n\nHowever, a `hcl.nomad` or `nomad` filetype should be defined.\nDescription of your jobs should be written in `.nomad` files for the LSP\nclient to configure the server's `root_dir` configuration option.",
  "ntt": "https://github.com/nokia/ntt Installation instructions can be found\n[here](https://github.com/nokia/ntt#Install). Can be configured by\npassing a \"settings\" object to vim.lsp.config('ntt'):\n\n``` lua\nvim.lsp.config('ntt', {\n    settings = {\n      ntt = {\n      }\n    }\n})\n```",
  "nushell": "https://github.com/nushell/nushell Nushell built-in language server.",
  "nxls": "https://github.com/nrwl/nx-console/tree/master/apps/nxls nxls, a\nlanguage server for Nx Workspaces `nxls` can be installed via `npm`:\n\n``` sh\nnpm i -g nxls\n```",
  "ocamllsp": "https://github.com/ocaml/ocaml-lsp `ocaml-lsp` can be installed as\ndescribed in [installation\nguide](https://github.com/ocaml/ocaml-lsp#installation). To install the\nlsp server in a particular opam switch:\n\n``` sh\nopam install ocaml-lsp-server\n```",
  "ols": "https://github.com/DanielGavin/ols `Odin Language Server`.",
  "omnisharp": "https://github.com/omnisharp/omnisharp-roslyn OmniSharp server based on\nRoslyn workspaces `omnisharp-roslyn` can be installed by downloading and\nextracting a release from\n[here](https://github.com/OmniSharp/omnisharp-roslyn/releases).\nOmniSharp can also be built from source by following the instructions\n[here](https://github.com/omnisharp/omnisharp-roslyn#downloading-omnisharp).\nOmniSharp requires the\n[dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. For\n`go_to_definition` to work fully, extended `textDocument/definition`\nhandler is needed, for example see\n[omnisharp-extended-lsp.nvim](https://github.com/Hoffs/omnisharp-extended-lsp.nvim)",
  "opencl_ls": "https://github.com/Galarius/opencl-language-server Build instructions\ncan be found\n[here](https://github.com/Galarius/opencl-language-server/blob/main/_dev/build.md).\nPrebuilt binaries are available for Linux, macOS and Windows\n[here](https://github.com/Galarius/opencl-language-server/releases).",
  "openscad_ls": "https://github.com/dzhu/openscad-language-server A Language Server\nProtocol server for OpenSCAD You can build and install\n`openscad-language-server` binary with `cargo`:\n\n``` sh\ncargo install openscad-language-server\n```\n\nVim does not have built-in syntax for the `openscad` filetype currently.\nThis can be added via an autocmd:\n\n``` lua\nvim.cmd [[ autocmd BufRead,BufNewFile *.scad set filetype=openscad ]]\n```\n\nor by installing a filetype plugin such as\nhttps://github.com/sirtaj/vim-openscad",
  "openscad_lsp": "https://github.com/Leathong/openscad-LSP A Language Server Protocol\nserver for OpenSCAD You can build and install `openscad-lsp` binary with\n`cargo`:\n\n``` sh\ncargo install openscad-lsp\n```",
  "oso": "https://www.osohq.com/docs/develop/local-dev/env-setup Oso Polar\nlanguage server. `oso-cloud` can be installed by following the\ninstructions\n[here](https://www.osohq.com/docs/develop/local-dev/env-setup). The\ndefault `cmd` assumes that the `oso-cloud` binary can be found in the\n`$PATH`. You may need to configure the filetype for Polar (\\*.polar)\nfiles:\n\n    autocmd BufNewFile,BufRead *.polar set filetype=polar\n\nor \\`\\`\\`lua vim.filetype.add({ pattern = { \\['.*/*.polar'\\] = 'polar',\n}, }) Alternatively, you may use a syntax plugin like\nhttps://github.com/osohq/polar.vim",
  "oxlint": "",
  "pact_ls": "https://github.com/kadena-io/pact-lsp The Pact language server",
  "pasls": "https://github.com/genericptr/pascal-language-server An LSP server\nimplementation for Pascal variants that are supported by Free Pascal,\nincluding Object Pascal. It uses CodeTools from Lazarus as backend.\nFirst set `cmd` to the Pascal lsp binary. Customization options are\npassed to pasls as environment variables for example in your `.bashrc`:\n\n``` bash\nexport FPCDIR='/usr/lib/fpc/src'      # FPC source directory (This is the only required option for the server to work).\nexport PP='/usr/lib/fpc/3.2.2/ppcx64' # Path to the Free Pascal compiler executable.\nexport LAZARUSDIR='/usr/lib/lazarus'  # Path to the Lazarus sources.\nexport FPCTARGET=''                   # Target operating system for cross compiling.\nexport FPCTARGETCPU='x86_64'          # Target CPU for cross compiling.\n```",
  "pbls": "https://git.sr.ht/\\~rrc/pbls Prerequisites: Ensure protoc is on your\n\\$PATH. `pbls` can be installed via `cargo install`:\n\n``` sh\ncargo install --git https://git.sr.ht/~rrc/pbls\n```\n\npbls is a Language Server for protobuf",
  "perlls": "https://github.com/richterger/Perl-LanguageServer/tree/master/clients/vscode/perl\n`Perl-LanguageServer`, a language server for Perl. To use the language\nserver, ensure that you have Perl::LanguageServer installed and perl\ncommand is on your path.",
  "perlnavigator": "https://github.com/bscan/PerlNavigator A Perl language server. It can be\ninstalled via npm:\n\n``` sh\nnpm i -g perlnavigator-server\n```\n\nAt minimum, you will need `perl` in your path. If you want to use a\nnon-standard `perl` you will need to set your configuration like so:\n\n``` lua\nsettings = {\n  perlnavigator = {\n    perlPath = '/some/odd/location/my-perl'\n  }\n}\n```\n\nThe `contributes.configuration.properties` section of `perlnavigator`'s\n`package.json` has all available configuration settings. All settings\nhave a reasonable default, but, at minimum, you may want to point\n`perlnavigator` at your `perltidy` and `perlcritic` configurations.",
  "perlpls": "https://github.com/FractalBoy/perl-language-server\nhttps://metacpan.org/pod/PLS `PLS`, another language server for Perl. To\nuse the language server, ensure that you have PLS installed and that it\nis in your path",
  "pest_ls": "https://github.com/pest-parser/pest-ide-tools Language server for pest\ngrammars.",
  "phan": "https://github.com/phan/phan Installation:\nhttps://github.com/phan/phan#getting-started",
  "phpactor": "https://github.com/phpactor/phpactor Installation:\nhttps://phpactor.readthedocs.io/en/master/usage/standalone.html#global-installation",
  "phptools": "https://www.devsense.com/ `devsense-php-ls` can be installed via `npm`:\n\n``` sh\nnpm install -g devsense-php-ls\n```\n\n``` lua\n-- See https://www.npmjs.com/package/devsense-php-ls\ninit_options = {\n}\n-- See https://docs.devsense.com/vscode/configuration/\nsettings = {\n  php = {\n  };\n}\n```",
  "pico8_ls": "https://github.com/japhib/pico8-ls Full language support for the PICO-8\ndialect of Lua.",
  "please": "https://github.com/thought-machine/please High-performance extensible\nbuild system for reproducible multi-language builds. The `plz` binary\nwill automatically install the LSP for you on first run",
  "pli": "`pli_language_server` is a language server for the PL/I language used on\nIBM SystemZ mainframes. To learn how to configure the PL/I language\nserver, see the [PL/I Language Support\ndocumentation](https://github.com/zowe/zowe-pli-language-support).",
  "pony_language_server": "https://github.com/ponylang/pony-language-server Language server for the\nPony programming language",
  "poryscript_pls": "https://github.com/huderlem/poryscript-pls Language server for\nporyscript (a high level scripting language for GBA-era Pokémon\ndecompilation projects)",
  "postgres_lsp": "https://pg-language-server.com A collection of language tools and a\nLanguage Server Protocol (LSP) implementation for Postgres, focusing on\ndeveloper experience and reliable SQL tooling.",
  "powershell_es": "",
  "prismals": "Language Server for the Prisma JavaScript and TypeScript ORM\n`@prisma/language-server` can be installed via npm\n\n``` sh\nnpm install -g @prisma/language-server\n```",
  "prolog_ls": "https://github.com/jamesnvc/lsp_server Language Server Protocol server\nfor SWI-Prolog",
  "prosemd_lsp": "https://github.com/kitten/prosemd-lsp An experimental LSP for Markdown.\nPlease see the manual installation instructions:\nhttps://github.com/kitten/prosemd-lsp#manual-installation",
  "protols": "https://github.com/coder3101/protols `protols` can be installed via\n`cargo`:\n\n``` sh\ncargo install protols\n```\n\nA Language Server for proto3 files. It uses tree-sitter and runs in\nsingle file mode.",
  "psalm": "https://github.com/vimeo/psalm Can be installed with composer.\n\n``` sh\ncomposer global require vimeo/psalm\n```",
  "pug": "https://github.com/opa-oz/pug-lsp An implementation of the Language\nProtocol Server for [Pug.js](http://pugjs.org) PugLSP can be installed\nvia `go install github.com/opa-oz/pug-lsp@latest`, or manually\ndownloaded from [releases\npage](https://github.com/opa-oz/pug-lsp/releases)",
  "puppet": "LSP server for Puppet. Installation: - Clone the editor-services\nrepository: https://github.com/puppetlabs/puppet-editor-services -\nNavigate into that directory and run: `bundle install` - Install the\n'puppet-lint' gem: `gem install puppet-lint` - Add that repository to\n\\$PATH. - Ensure you can run `puppet-languageserver` from outside the\neditor-services directory.",
  "purescriptls": "https://github.com/nwolverson/purescript-language-server The\n`purescript-language-server` can be added to your project and `$PATH`\nvia \\* JavaScript package manager such as npm, pnpm, Yarn, et al. \\* Nix\nunder the `nodePackages` and `nodePackages_latest` package sets",
  "pylsp": "https://github.com/python-lsp/python-lsp-server A Python 3.6+\nimplementation of the Language Server Protocol. See the [project's\nREADME](https://github.com/python-lsp/python-lsp-server) for\ninstallation instructions. Configuration options are documented\n[here](https://github.com/python-lsp/python-lsp-server/blob/develop/CONFIGURATION.md).\nIn order to configure an option, it must be translated to a nested Lua\ntable and included in the `settings` argument to the\n`config('pylsp', {})` function. For example, in order to set the\n`pylsp.plugins.pycodestyle.ignore` option:\n\n``` lua\nvim.lsp.config('pylsp', {\n  settings = {\n    pylsp = {\n      plugins = {\n        pycodestyle = {\n          ignore = {'W391'},\n          maxLineLength = 100\n        }\n      }\n    }\n  }\n})\n```\n\nNote: This is a community fork of `pyls`.",
  "pylyzer": "https://github.com/mtshiba/pylyzer `pylyzer`, a fast static code\nanalyzer & language server for Python. `pylyzer` requires Erg as\ndependency, and finds it via `ERG_PATH` environment variable. This\nconfig sets `ERG_PATH=\"~/.erg\"`. Set `cmd_env` if you want to change it.\nTo install Erg, simply extract tarball/zip from [Erg\nreleases](https://github.com/erg-lang/erg/releases/latest) to the the\npath where you want to install it, e.g. `~/.erg`.",
  "pyre": "https://pyre-check.org/ `pyre` a static type checker for Python 3.\n`pyre` offers an extremely limited featureset. It currently only\nsupports diagnostics, which are triggered on save. Do not report issues\nfor missing features in `pyre` to `lspconfig`.",
  "pyrefly": "https://pyrefly.org/",
  "pyright": "https://github.com/microsoft/pyright `pyright`, a static type checker\nand language server for python",
  "qmlls": "https://doc.qt.io/qt-6/qtqml-tooling-qmlls.html \\> QML Language Server\nis a tool shipped with Qt that helps you write code in your favorite\n(LSP-supporting) editor. Source in the [QtDeclarative\nrepository](https://code.qt.io/cgit/qt/qtdeclarative.git/)",
  "quick_lint_js": "https://quick-lint-js.com/ quick-lint-js finds bugs in JavaScript\nprograms. See installation\n[instructions](https://quick-lint-js.com/install/)",
  "r_language_server": "[languageserver](https://github.com/REditorSupport/languageserver) is an\nimplementation of the Microsoft's Language Server Protocol for the R\nlanguage. It is released on CRAN and can be easily installed by\n\n``` r\ninstall.packages(\"languageserver\")\n```",
  "racket_langserver": "<https://github.com/jeapostrophe/racket-langserver> The Racket language\nserver. This project seeks to use\n[DrRacket](https://github.com/racket/drracket)'s public API to provide\nfunctionality that mimics DrRacket's code tools as closely as possible.\nInstall via `raco`: `raco pkg install racket-langserver`",
  "raku_navigator": "https://github.com/bscan/RakuNavigator A Raku language server **By\ndefault, raku_navigator doesn't have a `cmd` set.** This is because\nnvim-lspconfig does not make assumptions about your path. You have to\ninstall the language server manually. Clone the RakuNavigator repo,\ninstall based on the\n[instructions](https://github.com/bscan/raku_Navigator#installation-for-other-editors),\nand point `cmd` to `server.js` inside the `server/out` directory:\n\n``` lua\ncmd = {'node', '<path_to_repo>/server/out/server.js', '--stdio'}\n```\n\nAt minimum, you will need `raku` in your path. If you want to use a\nnon-standard `raku` you will need to set your configuration like so:\n\n``` lua\nsettings = {\n  raku_navigator = {\n    rakuPath = '/some/odd/location/my-raku'\n  }\n}\n```\n\nThe `contributes.configuration.properties` section of `raku_navigator`'s\n`package.json` has all available configuration settings. All settings\nhave a reasonable default, but, at minimum, you may want to point\n`raku_navigator` at your `raku_tidy` and `raku_critic` configurations.",
  "reason_ls": "Reason language server You can install reason language server from\n[reason-language-server](https://github.com/jaredly/reason-language-server)\nrepository.",
  "regal": "https://github.com/StyraInc/regal A linter for Rego, with support for\nrunning as an LSP server. `regal` can be installed by running:\n\n``` sh\ngo install github.com/StyraInc/regal@latest\n```",
  "regols": "https://github.com/kitagry/regols OPA Rego language server. `regols` can\nbe installed by running:\n\n``` sh\ngo install github.com/kitagry/regols@latest\n```",
  "remark_ls": "https://github.com/remarkjs/remark-language-server\n`remark-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g remark-language-server\n```\n\n`remark-language-server` uses the same [configuration\nfiles](https://github.com/remarkjs/remark/tree/main/packages/remark-cli#example-config-files-json-yaml-js)\nas `remark-cli`. This uses a plugin based system. Each plugin needs to\nbe installed locally using `npm` or `yarn`. For example, given the\nfollowing `.remarkrc.json`:\n\n``` json\n{\n  \"presets\": [\n    \"remark-preset-lint-recommended\"\n  ]\n}\n```\n\n`remark-preset-lint-recommended` needs to be installed in the local\nproject:\n\n``` sh\nnpm install remark-preset-lint-recommended\n```",
  "rescriptls": "https://github.com/rescript-lang/rescript-vscode/tree/master/server\nReScript Language Server can be installed via npm:\n\n``` sh\nnpm install -g @rescript/language-server\n```\n\nSee\n[package.json](https://github.com/rescript-lang/rescript-vscode/blob/master/package.json#L139)\nfor init_options supported. For example, in order to disable the\n`inlayHints` option:\n\n``` lua\nvim.lsp.config('rescriptls', {\n  settings = {\n    rescript = {\n      settings = {\n        inlayHints = { enable = false },\n      },\n    },\n  })\n}\n```\n\nDetect file changes: While using @rescript/language-server \\>= 1.63.0\nyou have to detect file changes by registering the didChangeWatchedFiles\nhook.\n\n``` lua\ncapabilities = {\n    workspace = {\n        didChangeWatchedFiles = {\n            dynamicRegistration = true,\n        },\n    },\n}\n```",
  "rls": "https://github.com/rust-lang/rls rls, a language server for Rust See\nhttps://github.com/rust-lang/rls#setup to setup rls itself. See\nhttps://github.com/rust-lang/rls#configuration for rls-specific\nsettings. All settings listed on the rls configuration section of the\nreadme must be set under settings.rust as follows:\n\n``` lua\nvim.lsp.config('rls', {\n  settings = {\n    rust = {\n      unstable_features = true,\n      build_on_save = false,\n      all_features = true,\n    },\n  },\n})\n```\n\nIf you want to use rls for a particular build, eg nightly, set cmd as\nfollows:\n\n``` lua\ncmd = {\"rustup\", \"run\", \"nightly\", \"rls\"}\n```",
  "rnix": "https://github.com/nix-community/rnix-lsp A language server for Nix\nproviding basic completion and formatting via nixpkgs-fmt. To install\nmanually, run `cargo install rnix-lsp`. If you are using nix, rnix-lsp\nis in nixpkgs. This server accepts configuration via the `settings` key.",
  "robotcode": "https://robotcode.io RobotCode - Language Server Protocol implementation\nfor Robot Framework.",
  "robotframework_ls": "https://github.com/robocorp/robotframework-lsp Language Server Protocol\nimplementation for Robot Framework.",
  "roc_ls": "https://github.com/roc-lang/roc/tree/main/crates/language_server#roc_language_server\nThe built-in language server for the Roc programming language.\n[Installation](https://github.com/roc-lang/roc/tree/main/crates/language_server#installing)",
  "rome": "https://rome.tools Language server for the Rome Frontend Toolchain.\n(Unmaintained, use [Biome](https://biomejs.dev/blog/annoucing-biome)\ninstead.)\n\n``` sh\nnpm install [-g] rome\n```",
  "roslyn_ls": "https://github.com/dotnet/roslyn",
  "rpmspec": "https://github.com/dcermak/rpm-spec-language-server Language server\nprotocol (LSP) support for RPM Spec files. `rpm-spec-language-server`\ncan be installed by running,\n\n``` sh\npip install rpm-spec-language-server\n```",
  "rubocop": "https://github.com/rubocop/rubocop",
  "ruby_lsp": "https://shopify.github.io/ruby-lsp/ This gem is an implementation of the\nlanguage server protocol specification for Ruby, used to improve editor\nfeatures. Install the gem. There's no need to require it, since the\nserver is used as a standalone executable.\n\n``` sh\ngem install ruby-lsp\n```",
  "ruff": "https://github.com/astral-sh/ruff A Language Server Protocol\nimplementation for Ruff, an extremely fast Python linter and code\nformatter, written in Rust. It can be installed via `pip`.\n\n``` sh\npip install ruff\n```\n\n**Available in Ruff `v0.4.5` in beta and stabilized in Ruff `v0.5.3`.**\nThis is the new built-in language server written in Rust. It supports\nthe same feature set as `ruff-lsp`, but with superior performance and no\ninstallation required. Note that the `ruff-lsp` server will continue to\nbe maintained until further notice. Server settings can be provided via:\n\n``` lua\nvim.lsp.config('ruff', {\n  init_options = {\n    settings = {\n      -- Server settings should go here\n    }\n  }\n})\n```\n\nRefer to the [documentation](https://docs.astral.sh/ruff/editors/) for\nmore details.",
  "ruff_lsp": "https://github.com/astral-sh/ruff-lsp A Language Server Protocol\nimplementation for Ruff, an extremely fast Python linter and code\ntransformation tool, written in Rust. It can be installed via pip.\n\n``` sh\npip install ruff-lsp\n```\n\nExtra CLI arguments for `ruff` can be provided via\n\n``` lua\nvim.lsp.config('ruff_lsp', {\n  init_options = {\n    settings = {\n      -- Any extra CLI arguments for `ruff` go here.\n      args = {},\n    }\n  }\n})\n```",
  "rumdl": "https://github.com/rvben/rumdl Markdown Linter and Formatter written in\nRust.",
  "rune_languageserver": "https://crates.io/crates/rune-languageserver A language server for the\n[Rune](https://rune-rs.github.io/) Language, an embeddable dynamic\nprogramming language for Rust",
  "rust_analyzer": "https://github.com/rust-lang/rust-analyzer rust-analyzer (aka rls 2.0),\na language server for Rust See\n[docs](https://rust-analyzer.github.io/book/configuration.html) for\nextra settings. The settings can be used like this:\n\n``` lua\nvim.lsp.config('rust_analyzer', {\n  settings = {\n    ['rust-analyzer'] = {\n      diagnostics = {\n        enable = false;\n      }\n    }\n  }\n})\n```\n\nNote: do not set `init_options` for this LS config, it will be\nautomatically populated by the contents of settings\\[\"rust-analyzer\"\\]\nper\nhttps://github.com/rust-lang/rust-analyzer/blob/eb5da56d839ae0a9e9f50774fa3eb78eb0964550/docs/dev/lsp-extensions.md?plain=1#L26.",
  "salt_ls": "Language server for Salt configuration files.\nhttps://github.com/dcermak/salt-lsp The language server can be installed\nwith `pip`:\n\n``` sh\npip install salt-lsp\n```",
  "scheme_langserver": "https://github.com/ufo5260987423/scheme-langserver `scheme-langserver`,\na language server protocol implementation for scheme. And for nvim user,\nplease add .sls to scheme file extension list.",
  "scry": "https://github.com/crystal-lang-tools/scry Crystal language server.",
  "selene3p_ls": "https://github.com/antonk52/lua-3p-language-servers 3rd party Language\nServer for Selene lua linter",
  "serve_d": "https://github.com/Pure-D/serve-d Microsoft language server protocol\nimplementation for D using workspace-d. Download a binary from\nhttps://github.com/Pure-D/serve-d/releases and put it in your \\$PATH.",
  "shopify_theme_ls": "https://shopify.dev/docs/api/shopify-cli [Language\nServer](https://shopify.dev/docs/themes/tools/cli/language-server) and\nTheme Check (linter) for Shopify themes. `shopify` can be installed via\nnpm `npm install -g @shopify/cli`. Note: This LSP already includes Theme\nCheck so you don't need to use the `theme_check` server configuration as\nwell.",
  "sixtyfps": "https://github.com/sixtyfpsui/sixtyfps `SixtyFPS`'s language server You\ncan build and install `sixtyfps-lsp` binary with `cargo`:\n\n``` sh\ncargo install sixtyfps-lsp\n```\n\nVim does not have built-in syntax for the `sixtyfps` filetype currently.\nThis can be added via an autocmd:\n\n``` lua\nvim.cmd [[ autocmd BufRead,BufNewFile *.60 set filetype=sixtyfps ]]\n```\n\nor by installing a filetype plugin such as\nhttps://github.com/RustemB/sixtyfps-vim",
  "slangd": "https://github.com/shader-slang/slang The `slangd` binary can be\ndownloaded as part of [slang\nreleases](https://github.com/shader-slang/slang/releases) or by\n[building `slang` from\nsource](https://github.com/shader-slang/slang/blob/master/docs/building.md).\nThe server can be configured by passing a \"settings\" object to\nvim.lsp.config('slangd'):\n\n``` lua\nvim.lsp.config('slangd', {\n  settings = {\n    slang = {\n      predefinedMacros = {\"MY_VALUE_MACRO=1\"},\n      inlayHints = {\n        deducedTypes = true,\n        parameterNames = true,\n      }\n    }\n  }\n})\n```\n\nAvailable options are documented\n[here](https://github.com/shader-slang/slang-vscode-extension/tree/main?tab=readme-ov-file#configurations)\nor in more detail\n[here](https://github.com/shader-slang/slang-vscode-extension/blob/main/package.json#L70).",
  "slint_lsp": "https://github.com/slint-ui/slint `Slint`'s language server You can\nbuild and install `slint-lsp` binary with `cargo`:\n\n``` sh\ncargo install slint-lsp\n```\n\nVim does not have built-in syntax for the `slint` filetype at this time.\nThis can be added via an autocmd:\n\n``` lua\nvim.cmd [[ autocmd BufRead,BufNewFile *.slint set filetype=slint ]]\n```",
  "smarty_ls": "https://github.com/landeaux/vscode-smarty-langserver-extracted Language\nserver for Smarty. `smarty-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g vscode-smarty-langserver-extracted\n```",
  "smithy_ls": "https://github.com/awslabs/smithy-language-server \"Smithy Language\nServer\", a Language server for the Smithy IDL. smithy-language-server\nhas no docs that say how to actually install it(?), so look at:\nhttps://github.com/smithy-lang/smithy-vscode/blob/600cfcf0db65edce85f02e6d50f5fa2b0862bc8d/src/extension.ts#L78\nMaven package:\nhttps://central.sonatype.com/artifact/software.amazon.smithy/smithy-language-server\nInstallation: 1. Install coursier, or any tool that can install maven\npackages. `brew install coursier` 2. The LS is auto-installed and\nlaunched by:\n`coursier launch software.amazon.smithy:smithy-language-server:0.7.0`",
  "snakeskin_ls": "https://www.npmjs.com/package/@snakeskin/cli `snakeskin cli` can be\ninstalled via `npm`:\n\n``` sh\nnpm install -g @snakeskin/cli\n```",
  "snyk_ls": "https://github.com/snyk/snyk-ls **[Snyk](https://snyk.io)** is a\ndeveloper security platform that helps you find and fix vulnerabilities\nin your code, open source dependencies, containers, and infrastructure\nas code. The Snyk Language Server provides real-time security scanning\nfor: - **Snyk Open Source**: Find and fix vulnerabilities in open source\ndependencies - **Snyk Code**: Find and fix security vulnerabilities in\nyour code - **Snyk Infrastructure as Code**: Find and fix security\nissues in Kubernetes, Terraform, and other IaC files \\## Authentication\n**Note**: Currently, only token-based authentication is supported in\nNeovim. 1. Get your API token from https://app.snyk.io/account 2. Set\nthe `SNYK_TOKEN` environment variable:\n`sh    export SNYK_TOKEN=\"your-token-here\"` \\## Trusted Folders Snyk\nrequires you to trust directories before scanning them. To avoid being\nprompted every time:\n\n``` lua\nvim.lsp.config('snyk_ls', {\n  init_options = {\n    trustedFolders = {\n      '/Users/yourname/projects',  -- Trust your projects directory\n      '/path/to/another/trusted/dir',\n    },\n  },\n})\n```\n\n**Important**: Trust the top-level directory where you store your\nrepositories, not individual repos. For example, if you work on\n`/Users/yourname/projects/my-app`, trust `/Users/yourname/projects`.\nOnly trust directories containing code you trust to scan. \\##\nConfiguration Full configuration options available at\nhttps://github.com/snyk/snyk-ls#configuration-1 \\### Advanced\nConfiguration For **non-default multi-tenant or single-tenant setups**,\nyou may need to specify: - `endpoint`: Custom Snyk API endpoint (e.g.,\n`https://api.eu.snyk.io` for EU, or your single-tenant URL) \\`\\`\\`",
  "solang": "See the\n[documentation](https://solang.readthedocs.io/en/latest/installing.html)\nfor installation instructions. The language server only provides the\nfollowing capabilities: \\* Syntax highlighting \\* Diagnostics \\* Hover\nThere is currently no support for completion, goto definition,\nreferences, or other functionality.",
  "solargraph": "https://solargraph.org/ solargraph, a language server for Ruby You can\ninstall solargraph via gem install.\n\n``` sh\ngem install --user-install solargraph\n```",
  "solc": "https://docs.soliditylang.org/en/latest/installing-solidity.html solc is\nthe native language server for the Solidity language.",
  "solidity": "https://github.com/qiuxiang/solidity-ls npm i solidity-ls -g Make sure\nthat solc is installed and it's the same version of the file.\nsolc-select is recommended. Solidity language server is a LSP with\nautocomplete, go to definition and diagnostics. If you use brownie, use\nthis root_markers: root_markers = { 'brownie-config.yaml', '.git' } on\nincludePath, you can add an extra path to search for external libs, on\nremapping you can remap lib \\<\\> path, like:\n\n``` lua\n{ solidity = { includePath = '/Users/your_user/.brownie/packages/', remapping = { [\"@OpenZeppelin/\"] = 'OpenZeppelin/openzeppelin-contracts@4.6.0/' } } }\n```\n\n**For brownie users** Change the root_markers to:\n\n``` lua\nroot_markers = { 'brownie-config.yaml', '.git' }\n```\n\nThe best way of using it is to have a package.json in your project\nfolder with the packages that you will use. After installing with\npackage.json, just create a `remappings.txt` with:\n\n    @OpenZeppelin/=node_modules/OpenZeppelin/openzeppelin-contracts@4.6.0/\n\nYou can omit the node_modules as well.",
  "solidity_ls": "https://github.com/juanfranblanco/vscode-solidity\n`vscode-solidity-server` can be installed via `npm`:\n\n``` sh\nnpm install -g vscode-solidity-server\n```\n\n`vscode-solidity-server` is a language server for the Solidity language\nported from the VSCode \"solidity\" extension.",
  "solidity_ls_nomicfoundation": "https://github.com/NomicFoundation/hardhat-vscode/blob/development/server/README.md\n`nomicfoundation-solidity-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g @nomicfoundation/solidity-language-server\n```\n\nA language server for the Solidity programming language, built by the\nNomic Foundation for the Ethereum community.",
  "somesass_ls": "https://github.com/wkillerud/some-sass/tree/main/packages/language-server\n`some-sass-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g some-sass-language-server\n```\n\nThe language server provides: - Full support for @use and @forward,\nincluding aliases, prefixes and hiding. - Workspace-wide code navigation\nand refactoring, such as Rename Symbol. - Rich documentation through\nSassDoc. - Language features for %placeholder-selectors, both when using\nthem and writing them. - Suggestions and hover info for built-in Sass\nmodules, when used with @use.",
  "sorbet": "https://sorbet.org Sorbet is a fast, powerful type checker designed for\nRuby. You can install Sorbet via gem install. You might also be\ninterested in how to set Sorbet up for new projects:\nhttps://sorbet.org/docs/adopting.\n\n``` sh\ngem install sorbet\n```",
  "sourcekit": "https://github.com/swiftlang/sourcekit-lsp Language server for Swift and\nC/C++/Objective-C.",
  "spectral": "https://github.com/luizcorreia/spectral-language-server\n`A flexible JSON/YAML linter for creating automated style guides, with baked in support for OpenAPI v2 & v3.`\n`spectral-language-server` can be installed via `npm`:\n\n``` sh\nnpm i -g spectral-language-server\n```\n\nSee\n[vscode-spectral](https://github.com/stoplightio/vscode-spectral#extension-settings)\nfor configuration options.",
  "spyglassmc_language_server": "https://github.com/SpyglassMC/Spyglass/tree/main/packages/language-server\nLanguage server for Minecraft datapacks. `spyglassmc-language-server`\ncan be installed via `npm`:\n\n``` sh\nnpm i -g @spyglassmc/language-server\n```\n\nYou may also need to configure the filetype:\n`autocmd BufNewFile,BufRead *.mcfunction set filetype=mcfunction` This\nis automatically done by\n[CrystalAlpha358/vim-mcfunction](https://github.com/CrystalAlpha358/vim-mcfunction),\nwhich also provide syntax highlight.",
  "sqlls": "https://github.com/joe-re/sql-language-server This LSP can be installed\nvia `npm`. Find further instructions on manual installation of the\nsql-language-server at\n[joe-re/sql-language-server](https://github.com/joe-re/sql-language-server).",
  "sqls": "https://github.com/sqls-server/sqls\n\n``` lua\nvim.lsp.config('sqls', {\n  cmd = {\"path/to/command\", \"-config\", \"path/to/config.yml\"};\n  ...\n})\n```\n\nSqls can be installed via\n`go install github.com/sqls-server/sqls@latest`. Instructions for\ncompiling Sqls from the source can be found at\n[sqls-server/sqls](https://github.com/sqls-server/sqls).",
  "sqruff": "https://github.com/quarylabs/sqruff `sqruff` can be installed by\nfollowing the instructions\n[here](https://github.com/quarylabs/sqruff?tab=readme-ov-file#installation)",
  "standardrb": "https://github.com/testdouble/standard Ruby Style Guide, with linter &\nautomatic code fixer.",
  "starlark_rust": "https://github.com/facebookexperimental/starlark-rust/ The LSP part of\n`starlark-rust` is not currently documented, but the implementation\nworks well for linting. This gives valuable warnings for potential\nissues in the code, but does not support refactorings. It can be\ninstalled with cargo: https://crates.io/crates/starlark",
  "starpls": "https://github.com/withered-magic/starpls `starpls` is an LSP\nimplementation for Starlark. Installation instructions can be found in\nthe project's README.",
  "statix": "https://github.com/nerdypepper/statix lints and suggestions for the nix\nprogramming language",
  "steep": "https://github.com/soutaro/steep `steep` is a static type checker for\nRuby. You need `Steepfile` to make it work. Generate it with\n`steep init`.",
  "stimulus_ls": "https://www.npmjs.com/package/stimulus-language-server `stimulus-lsp`\ncan be installed via `npm`:\n\n``` sh\nnpm install -g stimulus-language-server\n```\n\nor via `yarn`:\n\n``` sh\nyarn global add stimulus-language-server\n```",
  "stylelint_lsp": "https://github.com/bmatcuk/stylelint-lsp `stylelint-lsp` can be\ninstalled via `npm`:\n\n``` sh\nnpm i -g stylelint-lsp\n```\n\nCan be configured by passing a `settings.stylelintplus` object to\nvim.lsp.config('stylelint_lsp'):\n\n``` lua\nvim.lsp.config('stylelint_lsp', {\n  settings = {\n    stylelintplus = {\n      -- see available options in stylelint-lsp documentation\n    }\n  }\n})\n```",
  "stylua": "https://github.com/JohnnyMorganz/StyLua A deterministic code formatter\nfor Lua 5.1, 5.2, 5.3, 5.4, LuaJIT, Luau and CfxLua/FiveM Lua",
  "stylua3p_ls": "https://github.com/antonk52/lua-3p-language-servers 3rd party Language\nServer for Stylua lua formatter",
  "superhtml": "https://github.com/kristoff-it/superhtml HTML Language Server &\nTemplating Language Library This LSP is designed to tightly adhere to\nthe HTML spec as well as enforcing some additional rules that ensure\nHTML clarity. If you want to disable HTML support for another HTML LSP,\nadd the following to your configuration:\n\n``` lua\nvim.lsp.config('superhtml', {\n  filetypes = { 'superhtml' }\n})\n```",
  "svelte": "https://github.com/sveltejs/language-tools/tree/master/packages/language-server\nNote: assuming that [ts_ls](#ts_ls) is setup, full JavaScript/TypeScript\nsupport (find references, rename, etc of symbols in Svelte files when\nworking in JS/TS files) requires per-project installation and\nconfiguration of\n[typescript-svelte-plugin](https://github.com/sveltejs/language-tools/tree/master/packages/typescript-plugin#usage).\n`svelte-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g svelte-language-server\n```",
  "svlangserver": "https://github.com/imc-trading/svlangserver Language server for\nSystemVerilog. `svlangserver` can be installed via `npm`:\n\n``` sh\n$ npm install -g @imc-trading/svlangserver\n```",
  "svls": "https://github.com/dalance/svls Language server for verilog and\nSystemVerilog `svls` can be installed via `cargo`:\n`sh  cargo install svls`",
  "swift_mesonls": "https://github.com/JCWasmx86/Swift-MesonLSP Meson language server\nwritten in Swift",
  "syntax_tree": "https://ruby-syntax-tree.github.io/syntax_tree/ A fast Ruby parser and\nformatter. Syntax Tree is a suite of tools built on top of the internal\nCRuby parser. It provides the ability to generate a syntax tree from\nsource, as well as the tools necessary to inspect and manipulate that\nsyntax tree. It can be used to build formatters, linters, language\nservers, and more.\n\n``` sh\ngem install syntax_tree\n```",
  "systemd_ls": "Renamed to [systemd_lsp](#systemd_lsp)",
  "systemd_lsp": "https://github.com/JFryy/systemd-lsp A Language Server Protocol (LSP)\nimplementation for Systemd unit files, providing editing support with\nsyntax highlighting, diagnostics, autocompletion, and documentation.\n`systemd-lsp` can be installed via `cargo`:\n\n``` sh\ncargo install systemd-lsp\n```\n\nA language server implementation for Systemd unit files made in Rust.",
  "tabby_ml": "https://tabby.tabbyml.com/blog/running-tabby-as-a-language-server\nLanguage server for Tabby, an opensource, self-hosted AI coding\nassistant. `tabby-agent` can be installed via `npm`:\n\n``` sh\nnpm install --global tabby-agent\n```",
  "tailwindcss": "https://github.com/tailwindlabs/tailwindcss-intellisense Tailwind CSS\nLanguage Server can be installed via npm: npm install -g\n@tailwindcss/language-server",
  "taplo": "https://taplo.tamasfe.dev/cli/usage/language-server.html Language server\nfor Taplo, a TOML toolkit. `taplo-cli` can be installed via `cargo`:\n\n``` sh\ncargo install --features lsp --locked taplo-cli\n```",
  "tblgen_lsp_server": "https://mlir.llvm.org/docs/Tools/MLIRLSP/#tablegen-lsp-language-server--tblgen-lsp-server\nThe Language Server for the LLVM TableGen language `tblgen-lsp-server`\ncan be installed at the llvm-project repository\n(https://github.com/llvm/llvm-project)",
  "tclsp": "https://github.com/nmoroze/tclint `tclsp`, a language server for Tcl\n`tclsp` can be installed via `pipx`:\n\n``` sh\npipx install tclint\n```\n\nOr via `pip`:\n\n``` sh\npip install tclint\n```",
  "teal_ls": "https://github.com/teal-language/teal-language-server Install with:\n\n    luarocks install teal-language-server\n\nOptional Command Args: \\* \"--log-mode=by_date\" - Enable logging in\n\\$HOME/.cache/teal-language-server. Log name will be date + pid of\nprocess \\* \"--log-mode=by_proj_path\" - Enable logging in\n\\$HOME/.cache/teal-language-server. Log name will be project path + pid\nof process \\* \"--verbose=true\" - Increases log level. Does nothing\nunless log-mode is set",
  "templ": "https://templ.guide The official language server for the templ HTML\ntemplating language.",
  "termux_language_server": "https://github.com/termux/termux-language-server Language server for\nvarious bash scripts such as Arch PKGBUILD, Gentoo ebuild, Termux\nbuild.sh, etc.",
  "terraform_lsp": "https://github.com/juliosueiras/terraform-lsp Terraform language server\nDownload a released binary from\nhttps://github.com/juliosueiras/terraform-lsp/releases. From\nhttps://github.com/hashicorp/terraform-ls#terraform-ls-vs-terraform-lsp:\nBoth HashiCorp and the maintainer of terraform-lsp expressed interest in\ncollaborating on a language server and are working towards a *long-term*\ngoal of a single stable and feature-complete implementation. For the\ntime being both projects continue to exist, giving users the choice: -\n`terraform-ls` providing - overall stability (by relying only on public\nAPIs) - compatibility with any provider and any Terraform \\>=0.12.0\ncurrently less features - due to project being younger and relying on\npublic APIs which may not offer the same functionality yet -\n`terraform-lsp` providing - currently more features - compatibility with\na single particular Terraform (0.12.20 at time of writing) - configs\ndesigned for other 0.12 versions may work, but interpretation may be\ninaccurate - less stability (due to reliance on Terraform's own internal\npackages)",
  "terraformls": "https://github.com/hashicorp/terraform-ls Terraform language server\nDownload a released binary from\nhttps://github.com/hashicorp/terraform-ls/releases. From\nhttps://github.com/hashicorp/terraform-ls#terraform-ls-vs-terraform-lsp:\nBoth HashiCorp and the maintainer of terraform-lsp expressed interest in\ncollaborating on a language server and are working towards a *long-term*\ngoal of a single stable and feature-complete implementation. For the\ntime being both projects continue to exist, giving users the choice: -\n`terraform-ls` providing - overall stability (by relying only on public\nAPIs) - compatibility with any provider and any Terraform \\>=0.12.0\ncurrently less features - due to project being younger and relying on\npublic APIs which may not offer the same functionality yet -\n`terraform-lsp` providing - currently more features - compatibility with\na single particular Terraform (0.12.20 at time of writing) - configs\ndesigned for other 0.12 versions may work, but interpretation may be\ninaccurate - less stability (due to reliance on Terraform's own internal\npackages) Note, that the `settings` configuration option uses the\n`workspace/didChangeConfiguration` event, [which is not supported by\nterraform-ls](https://github.com/hashicorp/terraform-ls/blob/main/docs/features.md).\nInstead you should use `init_options` which passes the settings as part\nof the LSP initialize call [as is required by\nterraform-ls](https://github.com/hashicorp/terraform-ls/blob/main/docs/SETTINGS.md#how-to-pass-settings).",
  "texlab": "https://github.com/latex-lsp/texlab A completion engine built from\nscratch for (La)TeX. See\nhttps://github.com/latex-lsp/texlab/wiki/Configuration for configuration\noptions. There are some non standard commands supported, namely:\n`LspTexlabBuild`, `LspTexlabForward`, `LspTexlabCancelBuild`,\n`LspTexlabDependencyGraph`, `LspTexlabCleanArtifacts`,\n`LspTexlabCleanAuxiliary`, `LspTexlabFindEnvironments`, and\n`LspTexlabChangeEnvironment`.",
  "textlsp": "https://github.com/hangyav/textLSP `textLSP` is an LSP server for text\nspell and grammar checking with various AI tools. It supports multiple\ntext file formats, such as LaTeX, Org or txt. For the available text\nanalyzer tools and their configuration, see the\n[GitHub](https://github.com/hangyav/textLSP) page. By default, all\nanalyzers are disabled in textLSP, since most of them need special\nsettings. For quick testing, LanguageTool is enabled in the default\n`nvim-lspconfig` configuration. To install run: `pip install textLSP`",
  "tflint": "https://github.com/terraform-linters/tflint A pluggable Terraform linter\nthat can act as lsp server. Installation instructions can be found in\nhttps://github.com/terraform-linters/tflint#installation.",
  "theme_check": "https://github.com/Shopify/shopify-cli `theme-check-language-server` is\nbundled with `shopify-cli` or it can also be installed via\nhttps://github.com/Shopify/theme-check#installation **NOTE:** If\ninstalled via Homebrew, `cmd` must be set to 'theme-check-liquid-server'\n\n``` lua\nvim.lsp.config('theme_check, {\n  cmd = { 'theme-check-liquid-server' }\n})\n```",
  "thriftls": "https://github.com/joyme123/thrift-ls you can install thriftls by mason\nor download binary here: https://github.com/joyme123/thrift-ls/releases",
  "tilt_ls": "https://github.com/tilt-dev/tilt Tilt language server. You might need to\nadd filetype detection manually:\n\n``` vim\nautocmd BufRead Tiltfile setf=tiltfile\n```",
  "tinymist": "https://github.com/Myriad-Dreamin/tinymist An integrated language\nservice for Typst \\[taɪpst\\]. You can also call it \"微霭\" \\[wēi ǎi\\] in\nChinese. Currently some of Tinymist's workspace commands are supported,\nnamely: `LspTinymistExportSvg`, `LspTinymistExportPng`,\n`LspTinymistExportPdf`, `LspTinymistExportMarkdown`,\n`LspTinymistExportText`, `LspTinymistExportQuery`,\n`LspTinymistExportAnsiHighlight`, `LspTinymistGetServerInfo`,\n`LspTinymistGetDocumentTrace`, `LspTinymistGetWorkspaceLabels`,\n`LspTinymistGetDocumentMetrics`, and `LspTinymistPinMain`.",
  "tofu_ls": "[OpenTofu Language Server](https://github.com/opentofu/tofu-ls)",
  "tombi": "https://tombi-toml.github.io/tombi/ Language server for Tombi, a TOML\ntoolkit.",
  "ts_ls": "https://github.com/typescript-language-server/typescript-language-server\n`ts_ls`, aka `typescript-language-server`, is a Language Server Protocol\nimplementation for TypeScript wrapping `tsserver`. Note that `ts_ls` is\nnot `tsserver`. `typescript-language-server` depends on `typescript`.\nBoth packages can be installed via `npm`:\n\n``` sh\nnpm install -g typescript typescript-language-server\n```\n\nTo configure typescript language server, add a\n[`tsconfig.json`](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)\nor\n[`jsconfig.json`](https://code.visualstudio.com/docs/languages/jsconfig)\nto the root of your project. Here's an example that disables type\nchecking in JavaScript files.\n\n``` json\n{\n  \"compilerOptions\": {\n    \"module\": \"commonjs\",\n    \"target\": \"es6\",\n    \"checkJs\": false\n  },\n  \"exclude\": [\n    \"node_modules\"\n  ]\n}\n```\n\nUse the `:LspTypescriptSourceAction` command to see \"whole file\"\n(\"source\") code-actions such as: - organize imports - remove unused code\nUse the `:LspTypescriptGoToSourceDefinition` command to navigate to the\nsource definition of a symbol (e.g., jump to the original implementation\ninstead of type definitions). \\### Monorepo support `ts_ls` supports\nmonorepos by default. It will automatically find the `tsconfig.json` or\n`jsconfig.json` corresponding to the package you are working on. This\nworks without the need of spawning multiple instances of `ts_ls`, saving\nmemory. It is recommended to use the same version of TypeScript in all\npackages, and therefore have it available in your workspace root. The\nlocation of the TypeScript binary will be determined automatically, but\nonly once.",
  "ts_query_ls": "https://github.com/ribru17/ts_query_ls Can be configured by passing a\n\"settings\" object to `vim.lsp.config('ts_query_ls', {})`:\n\n``` lua\nvim.lsp.config('ts_query_ls', {\n  init_options = {\n    parser_install_directories = {\n      '/my/parser/install/dir',\n    },\n    -- This setting is provided by default\n    parser_aliases = {\n      ecma = 'javascript',\n      jsx = 'javascript',\n      php_only = 'php',\n    },\n  },\n})\n```",
  "tsgo": "https://github.com/microsoft/typescript-go `typescript-go` is\nexperimental port of the TypeScript compiler (tsc) and language server\n(tsserver) to the Go programming language. `tsgo` can be installed via\nnpm `npm install @typescript/native-preview`. \\### Monorepo support\n`tsgo` supports monorepos by default. It will automatically find the\n`tsconfig.json` or `jsconfig.json` corresponding to the package you are\nworking on. This works without the need of spawning multiple instances\nof `tsgo`, saving memory. It is recommended to use the same version of\nTypeScript in all packages, and therefore have it available in your\nworkspace root. The location of the TypeScript binary will be determined\nautomatically, but only once.",
  "tsp_server": "https://github.com/microsoft/typespec The language server for TypeSpec,\na language for defining cloud service APIs and shapes. `tsp-server` can\nbe installed together with the typespec compiler via `npm`:\n\n``` sh\nnpm install -g @typespec/compiler\n```",
  "ttags": "https://github.com/npezza93/ttags",
  "turbo_ls": "https://www.npmjs.com/package/turbo-language-server\n`turbo-language-server` can be installed via `npm`:\n\n``` sh\nnpm install -g turbo-language-server\n```\n\nor via `yarn`:\n\n``` sh\nyarn global add turbo-language-server\n```",
  "turtle_ls": "https://github.com/stardog-union/stardog-language-servers/tree/master/packages/turtle-language-server\n`turtle-language-server`, An editor-agnostic server providing language\nintelligence (diagnostics, hover tooltips, etc.) for the W3C standard\nTurtle RDF syntax via the Language Server Protocol. installable via npm\ninstall -g turtle-language-server or yarn global add\nturtle-language-server. requires node.",
  "tvm_ffi_navigator": "https://github.com/tqchen/ffi-navigator The Language Server for FFI\ncalls in TVM to be able jump between python and C++ FFI navigator can be\ninstalled with `pip install ffi-navigator`, buf for more details, please\nsee\nhttps://github.com/tqchen/ffi-navigator?tab=readme-ov-file#installation",
  "twiggy_language_server": "https://github.com/moetelo/twiggy `twiggy-language-server` can be\ninstalled via `npm`:\n\n``` sh\nnpm install -g twiggy-language-server\n```",
  "ty": "https://github.com/astral-sh/ty A Language Server Protocol\nimplementation for ty, an extremely fast Python type checker and\nlanguage server, written in Rust. For installation instructions, please\nrefer to the [ty\ndocumentation](https://github.com/astral-sh/ty/blob/main/README.md#getting-started).",
  "typeprof": "https://github.com/ruby/typeprof `typeprof` is the built-in analysis and\nLSP tool for Ruby 3.1+.",
  "typos_lsp": "https://github.com/crate-ci/typos https://github.com/tekumara/typos-lsp\nA Language Server Protocol implementation for Typos, a low\nfalse-positive source code spell checker, written in Rust. Download it\nfrom the releases page on GitHub:\nhttps://github.com/tekumara/typos-lsp/releases",
  "typst_lsp": "https://github.com/nvarner/typst-lsp Language server for Typst.",
  "uiua": "https://github.com/uiua-lang/uiua/ The builtin language server of the\nUiua interpreter. The Uiua interpreter can be installed with\n`cargo install uiua`",
  "ungrammar_languageserver": "https://github.com/binhtran432k/ungrammar-language-features Language\nServer for Ungrammar. Ungrammar Language Server can be installed via\nnpm:\n\n``` sh\nnpm i ungrammar-languageserver -g\n```",
  "unison": "https://github.com/unisonweb/unison/blob/trunk/docs/language-server.markdown",
  "unocss": "https://github.com/xna00/unocss-language-server UnoCSS Language Server\ncan be installed via npm:\n\n``` sh\nnpm i unocss-language-server -g\n```",
  "uvls": "https://codeberg.org/caradhras/uvls Language server for UVL, written\nusing tree sitter and rust. You can install the server easily using\ncargo:\n\n``` sh\ngit clone https://codeberg.org/caradhras/uvls\ncd  uvls\ncargo install --path .\n```\n\nNote: To activate properly nvim needs to know the uvl filetype. You can\nadd it via:\n\n``` lua\nvim.cmd([[au BufRead,BufNewFile *.uvl setfiletype uvl]])\n```",
  "v_analyzer": "https://github.com/vlang/v-analyzer V language server. `v-analyzer` can\nbe installed by following the instructions\n[here](https://github.com/vlang/v-analyzer#installation).",
  "vacuum": "You can install vacuum using mason or follow the instructions here:\nhttps://github.com/daveshanley/vacuum The file types are not detected\nautomatically, you can register them manually (see below) or override\nthe filetypes:\n\n``` lua\nvim.filetype.add {\n  pattern = {\n    ['openapi.*%.ya?ml'] = 'yaml.openapi',\n    ['openapi.*%.json'] = 'json.openapi',\n  },\n}\n```",
  "vala_ls": "https://github.com/Prince781/vala-language-server",
  "vale_ls": "https://github.com/errata-ai/vale-ls An implementation of the Language\nServer Protocol (LSP) for the Vale command-line tool.",
  "vectorcode_server": "https://github.com/Davidyz/VectorCode A Language Server Protocol\nimplementation for VectorCode, a code repository indexing tool.",
  "verible": "https://github.com/chipsalliance/verible A linter and formatter for\nverilog and SystemVerilog files. Release binaries can be downloaded from\n[here](https://github.com/chipsalliance/verible/releases) and placed in\na directory on PATH. See\nhttps://github.com/chipsalliance/verible/tree/master/verilog/tools/ls/README.md\nfor options.",
  "veridian": "https://github.com/vivekmalneedi/veridian A SystemVerilog\nLanguageServer. Download the latest release for your OS from the\nreleases page Install with slang feature, if C++17 compiler is\navailable:\n\n    cargo install --git https://github.com/vivekmalneedi/veridian.git --all-features\n\nInstall if C++17 compiler is not available:\n\n    cargo install --git https://github.com/vivekmalneedi/veridian.git",
  "veryl_ls": "https://github.com/veryl-lang/veryl Language server for Veryl `veryl-ls`\ncan be installed via `cargo`: `sh  cargo install veryl-ls`",
  "vespa_ls": "https://github.com/vespa-engine/vespa/tree/master/integration/schema-language-server\nVespa Language Server provides LSP features such as completion,\ndiagnostics, and go-to-definition for Vespa schema files (`.sd`),\nprofile files (`.profile`), and YQL query files (`.yql`). This language\nserver requires Java 17 or higher. You can build the jar from source.\nYou can override the default command by manually configuring it like\nthis:\n\n``` lua\nvim.lsp.config('vespa_ls', {\n  cmd = { 'java', '-jar', '/path/to/vespa-language-server.jar' },\n})\n```\n\nThe project root is determined based on the presence of a `.git`\ndirectory. To make Neovim recognize the proper filetypes, add the\nfollowing setting in `init.lua`: vim.filetype.add { extension = {\nprofile = 'sd', sd = 'sd', yql = 'yql', }, }",
  "vhdl_ls": "Install vhdl_ls from https://github.com/VHDL-LS/rust_hdl and add it to\npath Configuration The language server needs to know your library\nmapping to perform full analysis of the code. For this it uses a\nconfiguration file in the TOML format named vhdl_ls.toml. vhdl_ls will\nload configuration files in the following order of priority (first to\nlast): A file named .vhdl_ls.toml in the user home folder. A file name\nfrom the VHDL_LS_CONFIG environment variable. A file named vhdl_ls.toml\nin the workspace root. Settings in a later files overwrites those from\npreviously loaded files. Example vhdl_ls.toml\n\n    # File names are either absolute or relative to the parent folder of the vhdl_ls.toml file\n    [libraries]\n    lib2.files = [\n      'pkg2.vhd',\n    ]\n    lib1.files = [\n      'pkg1.vhd',\n      'tb_ent.vhd'\n    ]",
  "vimls": "https://github.com/iamcco/vim-language-server You can install\nvim-language-server via npm:\n\n``` sh\nnpm install -g vim-language-server\n```",
  "visualforce_ls": "https://github.com/forcedotcom/salesforcedx-vscode Language server for\nVisualforce. For manual installation, download the .vsix archive file\nfrom the\n[forcedotcom/salesforcedx-vscode](https://github.com/forcedotcom/salesforcedx-vscode)\nGitHub releases. Then, configure `cmd` to run the Node script at the\nunpacked location:\n\n``` lua\nvim.lsp.config('visualforce_ls', {\n  cmd = {\n    'node',\n    '/path/to/unpacked/archive/extension/node_modules/@salesforce/salesforcedx-visualforce-language-server/out/src/visualforceServer.js',\n    '--stdio'\n  }\n})\n```",
  "vls": "https://github.com/vlang/vls V language server. `v-language-server` can\nbe installed by following the instructions\n[here](https://github.com/vlang/vls#installation).",
  "volar": "Renamed to [vue_ls](#vue_ls)",
  "vscoqtop": "Renamed to [vsrocq](#vsrocq)",
  "vsrocq": "https://github.com/rocq-prover/vsrocq",
  "vtsls": "https://github.com/yioneko/vtsls `vtsls` can be installed with npm:\n\n``` sh\nnpm install -g @vtsls/language-server\n```\n\nTo configure a TypeScript project, add a\n[`tsconfig.json`](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)\nor\n[`jsconfig.json`](https://code.visualstudio.com/docs/languages/jsconfig)\nto the root of your project. \\### Vue support Since v3.0.0, the Vue\nlanguage server requires `vtsls` to support TypeScript.\n\n    -- If you are using mason.nvim, you can get the ts_plugin_path like this\n    -- For Mason v1,\n    -- local mason_registry = require('mason-registry')\n    -- local vue_language_server_path = mason_registry.get_package('vue-language-server'):get_install_path() .. '/node_modules/@vue/language-server'\n    -- For Mason v2,\n    -- local vue_language_server_path = vim.fn.expand '$MASON/packages' .. '/vue-language-server' .. '/node_modules/@vue/language-server'\n    -- or even\n    -- local vue_language_server_path = vim.fn.stdpath('data') .. \"/mason/packages/vue-language-server/node_modules/@vue/language-server\"\n    local vue_language_server_path = '/path/to/@vue/language-server'\n    local vue_plugin = {\n      name = '@vue/typescript-plugin',\n      location = vue_language_server_path,\n      languages = { 'vue' },\n      configNamespace = 'typescript',\n    }\n    vim.lsp.config('vtsls', {\n      settings = {\n        vtsls = {\n          tsserver = {\n            globalPlugins = {\n              vue_plugin,\n            },\n          },\n        },\n      },\n      filetypes = { 'typescript', 'javascript', 'javascriptreact', 'typescriptreact', 'vue' },\n    })\n\n- `location` MUST be defined. If the plugin is installed in\n  `node_modules`, `location` can have any value.\n- `languages` must include vue even if it is listed in filetypes.\n- `filetypes` is extended here to include Vue SFC. You must make sure\n  the Vue language server is setup. For example,\n\n<!-- -->\n\n    vim.lsp.enable('vue_ls')\n\nSee `vue_ls` section and\nhttps://github.com/vuejs/language-tools/wiki/Neovim for more\ninformation. \\### Monorepo support `vtsls` supports monorepos by\ndefault. It will automatically find the `tsconfig.json` or\n`jsconfig.json` corresponding to the package you are working on. This\nworks without the need of spawning multiple instances of `vtsls`, saving\nmemory. It is recommended to use the same version of TypeScript in all\npackages, and therefore have it available in your workspace root. The\nlocation of the TypeScript binary will be determined automatically, but\nonly once.",
  "vue_ls": "https://github.com/vuejs/language-tools/tree/master/packages/language-server\nThe official language server for Vue It can be installed via npm:\n\n``` sh\nnpm install -g @vue/language-server\n```\n\nThe language server only supports Vue 3 projects by default. For Vue 2\nprojects, [additional\nconfiguration](https://github.com/vuejs/language-tools/blob/master/extensions/vscode/README.md?plain=1#L19)\nare required. The Vue language server works in \"hybrid mode\" that\nexclusively manages the CSS/HTML sections. You need the `vtsls` server\nwith the `@vue/typescript-plugin` plugin to support TypeScript in `.vue`\nfiles. See `vtsls` section and\nhttps://github.com/vuejs/language-tools/wiki/Neovim for more\ninformation. NOTE: Since v3.0.0, the Vue Language Server [no longer\nsupports takeover\nmode](https://github.com/vuejs/language-tools/pull/5248).",
  "wasm_language_tools": "https://github.com/g-plane/wasm-language-tools WebAssembly Language\nTools aims to provide and improve the editing experience of WebAssembly\nText Format. It also provides an out-of-the-box formatter (a.k.a. pretty\nprinter) for WebAssembly Text Format.",
  "wc_language_server": "https://github.com/wc-toolkit/wc-language-server Web Components Language\nServer provides intelligent editor support for Web Components and custom\nelements. It offers advanced HTML diagnostics, completion, and\nvalidation for custom elements, including support for attribute types,\ndeprecation, and duplicate attribute detection. The language server uses\nthe [Custom Elements\nManifest](https://github.com/webcomponents/custom-elements-manifest) to\ngenerate component integration and validation information\n`wc-language-server` can be installed by following the instructions at\nthe [GitHub\nrepository](https://github.com/wc-toolkit/wc-language-server/blob/main/packages/neovim/README.md).\nThe default `cmd` assumes that the `wc-language-server` binary can be\nfound in `$PATH`. Alternatively, you can install it via\n[mason.nvim](https://github.com/williamboman/mason.nvim):\n\n``` vim\n:MasonInstall wc-language-server\n```\n\n**Configuration**\n\nThe language server reads settings from `wc.config.js` (or\n`.ts/.mjs/.cjs`) at the project root. Use it to customize manifest\nsources, file scoping, and diagnostic behavior. Example `wc.config.js`:\n\n``` js\nexport default {\n  // Fetch manifest from a custom path or URL\n  manifestSrc: './dist/custom-elements.json',\n  // Narrow which files opt into the language server\n  include: ['src/**/*.ts', 'src/**/*.html'],\n  // Skip specific globs\n  exclude: ['**/*.stories.ts'],\n  // Per-library overrides\n  libraries: {\n    '@your/pkg': {\n      manifestSrc: 'https://cdn.example.com/custom-elements.json',\n      tagFormatter: (tag) => tag.replace(/^x-/, 'my-'),\n    },\n  },\n  // Customize diagnostic severity levels\n  diagnosticSeverity: {\n    duplicateAttribute: 'warning',\n    unknownElement: 'info',\n  },\n};\n```\n\nSee the [configuration\ndocumentation](https://github.com/wc-toolkit/wc-language-server#configuration)\nfor more details.",
  "wgsl_analyzer": "https://github.com/wgsl-analyzer/wgsl-analyzer `wgsl-analyzer` can be\ninstalled via `cargo`:\n\n``` sh\ncargo install --git https://github.com/wgsl-analyzer/wgsl-analyzer wgsl-analyzer\n```",
  "yamlls": "https://github.com/redhat-developer/yaml-language-server\n`yaml-language-server` can be installed via `yarn`:\n\n``` sh\nyarn global add yaml-language-server\n```\n\nTo use a schema for validation, there are two options: 1. Add a modeline\nto the file. A modeline is a comment of the form:\n\n    # yaml-language-server: $schema=<urlToTheSchema|relativeFilePath|absoluteFilePath}>\n\nwhere the relative filepath is the path relative to the open yaml file,\nand the absolute filepath is the filepath relative to the filesystem\nroot ('/' on unix systems) 2. Associated a schema url, relative , or\nabsolute (to root of project, not to filesystem root) path to the a glob\npattern relative to the detected project root. Check\n`:checkhealth vim.lsp` to determine the resolved project root.\n\n``` lua\nvim.lsp.config('yamlls', {\n  ...\n  settings = {\n    yaml = {\n      ... -- other settings. note this overrides the lspconfig defaults.\n      schemas = {\n        [\"https://json.schemastore.org/github-workflow.json\"] = \"/.github/workflows/*\",\n        [\"../path/relative/to/file.yml\"] = \"/.github/workflows/*\",\n        [\"/path/from/root/of/project\"] = \"/.github/workflows/*\",\n      },\n    },\n  }\n})\n```\n\nCurrently, kubernetes is special-cased in yammls, see the following\nupstream issues: \\*\n[#211](https://github.com/redhat-developer/yaml-language-server/issues/211).\n\\*\n[#307](https://github.com/redhat-developer/yaml-language-server/issues/307).\nTo override a schema to use a specific k8s schema version (for example,\nto use 1.18):\n\n``` lua\nvim.lsp.config('yamlls', {\n  ...\n  settings = {\n    yaml = {\n      ... -- other settings. note this overrides the lspconfig defaults.\n      schemas = {\n        [\"https://raw.githubusercontent.com/yannh/kubernetes-json-schema/refs/heads/master/v1.32.1-standalone-strict/all.json\"] = \"/*.k8s.yaml\",\n        ... -- other schemas\n      },\n    },\n  }\n})\n```",
  "yang_lsp": "https://github.com/TypeFox/yang-lsp A Language Server for the YANG data\nmodeling language.",
  "yls": "https://pypi.org/project/yls-yara/ An YLS plugin adding YARA linting\ncapabilities. This plugin runs yara.compile on every save, parses the\nerrors, and returns list of diagnostic messages. Language Server:\nhttps://github.com/avast/yls",
  "ziggy": "https://ziggy-lang.io/documentation/ziggy-lsp/ Language server for the\nZiggy data serialization format",
  "ziggy_schema": "https://ziggy-lang.io/documentation/ziggy-lsp/ Language server for\nschema files of the Ziggy data serialization format",
  "zk": "https://github.com/zk-org/zk A plain text note-taking assistant",
  "zls": "https://github.com/zigtools/zls Zig LSP implementation + Zig Language\nServer",
  "zuban": "https://zubanls.com/ A high-performance Python Language Server and type\nchecker implemented in Rust, by the author of Jedi."
}
