Skip to content
Helix
News

Language Servers

To see a list of languages with default configurations, see language defaults

Language Server Configurations

Ansible

If your OS package manager hasn’t packaged ansible-language-server ↗, you can install it from NPM:

Terminal window
npm i -g @ansible/ansible-language-server

In turn, this binary will check if ansible-lint and yamllint are installed on your system and use them if found.

In addition to highlighting and linting your code, the Ansible language server can also be used to look up docs for Ansible keywords. With your cursor on a keyword, use “<space>k”.

Astro

https://github.com/withastro/language-tools/tree/main/packages/language-server ↗

Terminal window
npm i -g @astrojs/language-server

Sample settings in languages.toml

[language-server.astro-ls]
command = "astro-ls"
args = ["--stdio"]
config = {
  typescript = {
    tsdk = "/Users/user/.bun/install/global/node_modules/typescript/lib"
  },
  environment = "node"
}


[[language]]
name = "astro"
scope = "source.astro"
injection-regex = "astro"
file-types = ["astro"]
roots = ["package.json", "astro.config.mjs"]
language-servers = [ "astro-ls" ]

Please note that a valid config.typescript.tsdk path must be passed to the LSP config.

You will need typescript installed. If you have typescript installed globally you can find where by running npm list -g | head -1.

If you want to install typescript tsdk using your distribution’s package manager and not npm, note that the language server will search for a typescript.js located in ...somewhere.../lib/node_modules/typescript/lib/typescript.jsfile so you can find out where that is with e.g. cd / && find typescript.js.

AWK

https://github.com/Beaglefoot/awk-language-server ↗

Terminal window
npm i -g "awk-language-server@>=0.5.2"

Bash

Language server for Bash, written using tree-sitter in TypeScript.

https://github.com/mads-hartmann/bash-language-server ↗

bash-language-server can be installed via NPM:

Terminal window
npm i -g bash-language-server

Bass

https://github.com/vito/bass/releases/latest ↗

Bass’s language server is built in to the bass command as bass --lsp. See the Guide ↗ for more info.

Bicep

https://github.com/Azure/bicep/releases/latest ↗

The Bicep language server is published separately as a Windows package. Download the bicep-langserver.zip from the releases page.

To run this under Linux/WSL you will need to install the dotnet runtime for your OS ↗.

Unzip this in a directory of your choosing for example, /home/myUser/.cache/. Create the following bash script somewhere in your $PATH:

/usr/local/bin/bicep-langserver

Terminal window
##!/usr/bin/env bash


exec dotnet /home/myUser/.cache/bicep-langserver/Bicep.LangServer.dll

BQN

bqnlsp: https://git.sr.ht/~detegr/bqnlsp ↗, which depends on:

cbqn-sys ↗ and cbqn-rs ↗

Sample settings in languages.toml

[language-server.bqnlsp]
command = "bqnlsp"


[[language]]
name = "bqn"
file-types = ["bqn"]
comment-token = "#"
indent = { tab-width = 2, unit = "  " }
shebangs = ["bqn", "cbqn"]
roots = []
injection-regex = "bqn"
scope = "scope.bqn"
language-servers = ["bqnlsp"]
language-id = "bqn"

Note: you can input the glyphs by key remapping ↗ in config.toml like:

[keys.insert."\\"]
"=" = [ ":insert-output /bin/echo -n ×", "move_char_right" ]
minus = [ ":insert-output /bin/echo -n ÷", "move_char_right" ]
"+" = [ ":insert-output /bin/echo -n ⋆", "move_char_right" ]
## ...

C/C++

https://clangd.llvm.org/installation.html ↗

NOTE: Clang >= 9 is recommended!

clangd relies on a JSON compilation database ↗ specified as compile_commands.json or, for simpler projects, a compile_flags.txt. For details on how to automatically generate one using CMake look here ↗. Alternatively, you can use Bear ↗.

Clojure

Please go to the installation page. https://clojure-lsp.io/installation/ ↗

An example for MacOs/Linux (copied from the installation page)

Terminal window
brew remove clojure-lsp # if you have old clojure-lsp installed via brew
brew install clojure-lsp/brew/clojure-lsp-native

CMake

CMake LSP Implementation.

https://github.com/regen100/cmake-language-server ↗

Crystal

Core languages.toml contains configuration options, view at the top level of this repo.
Install the unofficial LSP server Crystalline ↗. Below is copied from the LSP repo.

Linux (x86_64)
Terminal window
wget https://github.com/elbywan/crystalline/releases/latest/download/crystalline_x86_64-unknown-linux-musl.gz -O crystalline.gz &&\
gzip -d crystalline.gz &&\
chmod u+x crystalline

####### ArchLinux

Terminal window
yay -S crystalline
MacOS

Install using homebrew ↗:

Terminal window
brew install crystalline

CSS

https://github.com/hrsh7th/vscode-langservers-extracted ↗

vscode-css-language-server can be installed via npm:

Terminal window
npm i -g vscode-langservers-extracted

C#

https://github.com/omnisharp/omnisharp-roslyn ↗ OmniSharp server based on Roslyn workspaces

omnisharp-roslyn can be installed by downloading and extracting a release for your platform from here ↗. Omnisharp can also be built from source by following the instructions here ↗.

Omnisharp requires the dotnet-sdk ↗ to be installed.

Usage

Linux and Windows

To use Omnisharp, you only need to have the OmniSharp binary in your environment path. The default languages.toml configuration should work fine.

macOS

Download the -netX.0 build. Because OmniSharp is not shipped as a binary file, instead as OmniSharp.dll, it needs to be run using dotnet. As such the languages.toml config should be changed to this:

[language-server.omnisharp]
command = "dotnet"
args = [ "path/to/OmniSharp.dll", "--languageserver" ]

If the language server immediately exits or otherwise doesn’t appear to work, try running dotnet restore and/or dotnet build in the current project directory.

D

Serve-D.

https://github.com/Pure-D/serve-d ↗

Install using dub fetch serve-d

Dart

Language server for dart.

https://github.com/dart-lang/sdk/tree/master/pkg/analysis_server/tool/lsp_spec ↗

Deno

Install Deno from https://docs.deno.com/runtime/getting_started/installation/ ↗

Deno requires custom configuration in languages.toml see https://github.com/denoland/deno/issues/14455 ↗

[[language]]
name = "javascript"
shebangs = ["deno"]
roots = ["deno.json", "deno.jsonc"]
file-types = ["js"]
language-servers = ["deno-lsp"]
auto-format = true
[[language]]
name = "typescript"
shebangs = ["deno"]
roots = ["deno.json", "deno.jsonc"]
file-types = ["ts"]
language-servers = ["deno-lsp"]
auto-format = true
[[language]]
name = "jsx"
shebangs = ["deno"]
roots = ["deno.json", "deno.jsonc"]
file-types = ["jsx"]
language-servers = ["deno-lsp"]
auto-format = true
[[language]]
name = "tsx"
shebangs = ["deno"]
roots = ["deno.json", "deno.jsonc"]
file-types = ["tsx"]
language-servers = ["deno-lsp"]
auto-format = true






[language-server.deno-lsp]
command = "deno"
args = ["lsp"]
environment = { NO_COLOR = "1" }


[language-server.deno-lsp.config.deno]
enable = true
## Uncomment to enable completion of unstable features of Deno
## unstable = true
## Uncomment to cache dependencies on save
## cacheOnSave = true
## Enable completion of importing from registries
## Enable completion of function calls
suggest = { completeFunctionCalls = false, imports = { hosts = { "https://deno.land" = true } } }
## suggest = { imports = { hosts = { "https://deno.land" = true, "https://crux.land" = true, "https://x.nest.land" = true } } }
## Uncomment to enable inlay hints
## inlayHints.parameterNames.enabled = "all"
## inlayHints.parameterTypes.enabled = true
## inlayHints.variableTypes.enabled = true
## inlayHints.propertyDeclarationTypes.enabled  = true
## inlayHints.functionLikeReturnTypes.enabled = true
## inlayHints.enumMemberValues.enabled = true

Note that some lsp commands are not currently supported, in particular go_to_definition because it requires a Deno lsp extension https://deno.land/manual/language_server/overview ↗.

Docker

https://github.com/rcjsuen/dockerfile-language-server-nodejs ↗

docker-langserver can be installed via npm:

Terminal window
npm install -g dockerfile-language-server-nodejs

Docker Compose

https://github.com/microsoft/compose-language-service ↗

docker-compose-langserver can be installed via npm:

Terminal window
npm install -g @microsoft/compose-language-service

dot Graphviz

https://github.com/nikeee/dot-language-server ↗

Terminal window
npm i -g dot-language-server

Elixir

https://github.com/elixir-lsp/elixir-ls ↗

elixir-ls can be installed by following the instructions here ↗.

Terminal window
curl -fLO https://github.com/elixir-lsp/elixir-ls/releases/latest/download/elixir-ls.zip
unzip elixir-ls.zip -d /path/to/elixir-ls
## Unix
chmod +x /path/to/elixir-ls/language_server.sh

Rename language_server.sh to elixir-ls and add it to your $PATH as this is how helix expects to find it.

MacOS

Install using homebrew ↗:

Terminal window
brew install elixir-ls

Elm

https://github.com/elm-tooling/elm-language-server#installation ↗

Terminal window
npm install -g elm elm-test elm-format @elm-tooling/elm-language-server

Forth

https://github.com/alexanderbrevig/forth-lsp#install ↗

Terminal window
cargo install forth-lsp

FSharp/F#

https://github.com/fsharp/FsAutoComplete ↗

Terminal window
dotnet tool install --global fsautocomplete

GDScript

We need to install nc or netcat. Port 6005 is used in Godot 4.0 beta6. You will find the right value in the editor configuration panel.

[language-server.godot]
command = "nc"
args = [ "127.0.0.1", "6005"]


[[language]]
name = "gdscript"
language-servers = [ "godot" ]

For Windows 10/11

Use winget to install nmap. This will install ncat.

Terminal window
winget install nmap

Once installed, make sure the folder that nmap is now located at is added to your PATH, as winget fails to do this automatically for some people.

In Godot 3.5.1 port used is 6008. You have to change the command used also. Instead of nc type ncat and modify the port. You can find the port when you open the Godot editor and navigate here: Editor -> Editor Settings -> Network -> Language Server -> Remote Port.

[language-server.godot]
command = "ncat"
args = [ "127.0.0.1", "6008"]


[[language]]
name = "gdscript"
language-servers = [ "godot" ]

Gleam

Starting with version 0.21.0, the Gleam language server is built-in to the gleam command-line interface. See the official announcement for more information. ↗

Terminal window
gleam lsp

Go

The folder for go packages (typically $HOME/go/bin) will need to be added to your PATH for any of the below to work.

Install tools

go install golang.org/x/tools/gopls@latest                            # LSP
go install github.com/go-delve/delve/cmd/dlv@latest                   # Debugger
go install golang.org/x/tools/cmd/goimports@latest                    # Formatter
go install github.com/nametake/golangci-lint-langserver@latest        # Linter
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest # Linter cli

Autoformatting

The LSP formatter (gofmt) does not fix imports, goimports should be used instead.

languages.toml

[[language]]
name = "go"
auto-format = true
formatter = { command = "goimports" }

GraphQL

https://github.com/graphql/graphiql/blob/main/packages/graphql-language-service-cli/ ↗

Terminal window
npm i -g graphql-language-service-cli

Haskell

Haskell Language Server.

https://github.com/haskell/haskell-language-server ↗

Helm

The Helm-ls installation guide can be found under the “Getting Started” section in the readme.

https://github.com/mrjosh/helm-ls#getting-started ↗

HTML

vscode-html-language-server

https://github.com/hrsh7th/vscode-langservers-extracted ↗

vscode-html-language-server can be installed via npm:

Terminal window
npm i -g vscode-langservers-extracted

superhtml

https://github.com/kristoff-it/superhtml ↗

Java

https://github.com/eclipse/eclipse.jdt.ls ↗

Installation instructions can be found on the projects README ↗.

On macOS installation can also be done via brew install jdtls.

On debian based distros try a fantastic install script made by eruizc-dev ↗: jdtls-launcher ↗.

For the Arch Linux: yay -Sy jdtls AUR jdtls source ↗.

After installing, test to see if the jdtls works out of the box (it should work for the debian script). For versions older than 1.16.0: the -data parameter must be passed to jdtls and it must be different for each project. This can be achieved by adding a .helix/languages.toml configuration to the project root:

[language-server]
jdtls = { command = "jdtls" }
language-server = { command = "jdtls", args = [
  "-data", "/home/<USER>/.cache/jdtls/workspace"
  ]}


[[language]]
name = "java"
scope = "source.java"
injection-regex = "java"
file-types = ["java"]
roots = ["pom.xml", "build.gradle", ]
indent = { tab-width = 4, unit = "    " }
language-servers = [ "jdtls" ]

Note: the -data parameter must be up one directory from the project directory.

JavaScript

See tsserver ↗.

JSON

https://github.com/hrsh7th/vscode-langservers-extracted ↗

vscode-json-language-server, a language server for JSON and JSON schema

vscode-json-language-server can be installed via npm:

Terminal window
npm i -g vscode-langservers-extracted

Available settings can be found here: https://github.com/microsoft/vscode/blob/4f69cdf95a12cef48d405b38bf7812a7f297c310/extensions/json-language-features/server/src/jsonServer.ts#L183 ↗

Usage

config = { "provideFormatter" = true, "json" = { "keepLines" = { "enable" = true } } }

Jsonnet

https://github.com/grafana/jsonnet-language-server ↗

A Language Server Protocol (LSP) ↗ server for Jsonnet ↗.

Can be installed either via the latest release binary ↗ or if you have golang installed, you can use:

Terminal window
go install github.com/grafana/jsonnet-language-server@latest

Julia

https://github.com/julia-vscode/LanguageServer.jl ↗

LanguageServer.jl can be installed with julia and Pkg:

Terminal window
julia -e 'using Pkg; Pkg.add("LanguageServer")'

To update an existing install, use the following command:

Terminal window
julia -e 'using Pkg; Pkg.update()'

Kotlin

A Kotlin language server which was developed for internal usage and released afterward. Maintaining is not done by the original author, but by fwcd.

It is built via gradle and developed on GitHub. Source and additional description: https://github.com/fwcd/kotlin-language-server ↗

LaTex

TexLab ↗: A cross-platform implementation of the Language Server Protocol ↗ providing rich cross-editing support for the LaTeX ↗ typesetting system.

Add the following to your languages.toml to enable build on save:

[language-server.texlab.config.texlab.build]
onSave = true

TexLab can be further configured to jump to your current location in the pdf following the build, among other useful things. For all available options, see the TexLab wiki ↗. Everything under the texlab key goes under language-server.texlab.config.texlab (or possibly language.config.texlab on older releases). For instance, setting the texlab.build.onSave property to true (as per the TexLab wiki ↗) is achieved with the above languages.toml.

Lean 3

https://github.com/leanprover/lean-client-js/tree/master/lean-language-server ↗

Lean installation instructions can be found here ↗.

Once Lean is installed, you can install the Lean 3 language server by running

Terminal window
npm install -g lean-language-server

Lua

Binaries are available from: https://github.com/LuaLS/lua-language-server/releases ↗

mac

Terminal window
brew install lua-language-server

Markdoc

@markdoc/language-server ↗ - an experimental language server for markdoc. markdoc-ls should be available after installation.

Install using

Terminal window
npm install -g @markdoc/language-server

Markdown

Marksman

The default language server is Marksman: https://github.com/artempyanykh/marksman ↗

Binaries are available from: https://github.com/artempyanykh/marksman/releases ↗

macOS and Linux

Terminal window
brew install marksman or yay -S marksman-bin

Windows

Terminal window
scoop install marksman

ltex-ls

As an alternative you can use ltex-ls which provides grammar and spelling errors in markup documents: https://valentjn.github.io/ltex/ ↗

[[language]]
name = "markdown"
language-servers = [ "marksman", "ltex-ls" ]

Additional configuration settings can be added, for example to disable the profanity rules and add the word builtin to two dictionaries:

[language-server.ltex-ls.config]
ltex.disabledRules = { "en-US" = ["PROFANITY"], "en-GB" = ["PROFANITY"] }
ltex.dictionary = { "en-US" = ["builtin"], "en-GB" = ["builtin"] }

Currently, the ability to add to your user dictionary while running Helix is not supported ↗, so adding words to the config is the best workaround.

markdown-oxide

An alternative to marksman that provides support for advanced markdown PKM systems in your favorite text editor. It features complete compatibility with Obsidian.md markdown syntax and bases its features on the features of the Obsidian.md editor. For a list of all features, check out the README ↗

  • It can be installed for Arch from the AUR under the name markdown-oxide-git
Terminal window
paru -S markdown-oxide-git
  • Or it can be installed by cargo
Terminal window
cargo install --git https://github.com/Feel-ix-343/markdown-oxide.git markdown-oxide

MATLAB

matlab-language-server ↗

Note: as per the README, “MATLAB language server requires MATLAB version R2021a or later.”

[language-server.matlab-ls]
command = "matlab-language-server"
args = ["--stdio"]


[language-server.matlab-ls.config.MATLAB]
indexWorkspace = false
installPath = "/PATH/TO/MATLAB/INSTALLATION"
matlabConnectionTiming = "onStart"
telemetry = false


[[language]]
name = "matlab"
scope = "source.m"
file-types = ["m"]
language-servers = ["matlab-ls"]
comment-token = "%"
shebangs = ["octave-cli", "matlab"]
indent = { tab-width = 2, unit = "  " }

Mint

https://www.mint-lang.com ↗

Install Mint using the instructions ↗. The language server is included since version 0.12.0.

Mojo

https://www.modular.com/mojo ↗

  • Install the Modular CLI
  • Install the Mojo SDK

See this PR: https://github.com/helix-editor/helix/pull/8583 ↗

Nim

https://github.com/nim-lang/langserver ↗

Terminal window
## May require choosenim
nimble install nimlangserver

Nix

The default language server is nil since the 2022-12 release.

https://github.com/oxalica/nil ↗

This program is available in NixOS/nixpkgs ↗ under attribute nil, and is regularly updated.

  • If you use nix-env, run nix-env -iA nixpkgs.nil
  • If you use nix profile, run nix profile install nixpkgs#nil
  • Check out the GitHub repository for additional options

The formatter nixpkgs-fmt is not included and can be installed with nix-env -iA nixpkgs.nixpkgs-fmt

To set up the formatter, set the following in your languages.toml :

[[language]]
name = "nix"
formatter = { command = "nixpkgs-fmt" }

To use the previous default language server, check out https://github.com/nix-community/rnix-lsp ↗

OCaml

https://github.com/ocaml/ocaml-lsp ↗

The OCaml language server ocamllsp can be installed via OPAM:

Terminal window
opam install ocaml-lsp-server

Odin

ols ↗ - https://github.com/DanielGavin/ols ↗

Provides syntax highlighting, auto-complete, code formatting and more for Odin.

OpenPolicyAgent

An implementation of the language server protocol for OpenPolicyAgent’s rego.

You can download it from its releases page ↗, or

Terminal window
$ go install github.com/kitagry/regols@latest

Perl

https://github.com/bscan/PerlNavigator ↗

Provides syntax checking, autocompletion, perlcritic, code navigation, hover for Perl.

Implemented as a Language Server using the Microsoft LSP libraries along with Perl doing the syntax checking and parsing.

Perl Navigator can be installed by downloading the latest release for your platform at the project’s releases page ↗ and putting the perlnavigator executable somewhere in your PATH.

Pest

https://github.com/pest-parser/pest-ide-tools ↗

This repository contains an implementation of the Language Server Protocol in Rust, for the Pest parser generator.

PHP

Phpactor

https://phpactor.readthedocs.io/en/master/index.html ↗

Phpactor requires PHP 8.1.

You can download phpactor.phar as follows:

Terminal window
curl -Lo phpactor.phar https://github.com/phpactor/phpactor/releases/latest/download/phpactor.phar

Then make it executable and symlink it somewhere in your PATH ↗:

Terminal window
chmod a+x phpactor.phar
mv phpactor.phar ~/.local/bin/phpactor

Check support using the status command:

Terminal window
phpactor status
✔ Composer detected - faster class location and more features!
✔ Git detected - enables faster refactorings in your repository scope!

Then, to enable this LSP you have to create a file languages.toml in your project directory .helix/languages.toml and place the following code inside (or if you want you could do this to helix languages.toml file globally):

[language-server.phpactor]
command = "phpactor"
args = [ "language-server" ]
[[language]]
name = "php"
language-servers = [ "phpactor" ]

Intelephense

[!WARNING] Intelephense is proprietary, so be sure to review its licensing terms.

https://intelephense.com ↗

intelephense can be installed via npm:

Terminal window
npm install -g intelephense
Premium version

To enable the premium features you have to provide a license key for which you have a few options:

  1. Adding the license key directly to your languages.toml file:
[language-server.intelephense.config]
licenceKey = "MY_LICENSE_KEY"
  1. Adding the path to your license file
[language-server.intelephense.config]
licenceKey = "/home/username/.config/intelephense/license.txt"
  1. Adding the license file to your home directory under $HOME/intelephense/licence.txt

Note: Keep in mind how the word is written licenceKey and not licenseKey, also for step 3) it has to be licence.txt.

PKGBUILD

https://github.com/termux/termux-language-server ↗

Archlinux

Terminal window
yay -S termux-language-server

PowerShell

Syntax highlighting is not currently possible as there is no PowerShell treesitter. But auto-completion can be achieved by the following configuration. Download the latest PowerShellEditorServices ↗ zip and extract it. In this example, I extracted it to C:\projects\powershell.

[[language]]
name = "powershell"
scope = "source.ps1"
file-types = ["ps1", "psm1"]
roots = [".git"]
comment-token = "#"
indent = { tab-width = 4, unit = "    " }
language-servers = [ "powershell-editor-services" ]


[language-server.powershell-editor-services]
command = "pwsh"
args = ["-NoLogo", "-NoProfile", "-Command", "C:\\projects\\powershell\\PowerShellEditorServices\\PowerShellEditorServices\\Start-EditorServices.ps1 -BundledModulesPath C:\\projects\\
powershell\\PowerShellEditorServices -SessionDetailsPath C:\\projects\\powershell\\PowerShellEditorServices\\PowerShellEditorServices.sessions.json -LogPath C:\\projects\\powershell\\
PowerShellEditorServices\\PowerShellEditorServices.log -FeatureFlags @() -AdditionalModules @() -HostName helix -HostProfileId 0 -HostVersion 1.0.0 -Stdio -LogLevel Normal"]

Prisma

https://github.com/prisma/language-tools/tree/main/packages/language-server ↗

prisma-language-server can be installed via npm:

Terminal window
npm install -g @prisma/language-server

Prolog

An implementation of the language server protocol for SWI-Prolog

https://github.com/jamesnvc/lsp_server ↗

Install the swi-prolog package and run swipl:

?- pack_install(lsp_server).

Python

pylsp

python-lsp/python-lsp-server ↗ (pylsp) is a fork of the python-language-server project (pyls), maintained by the Spyder IDE team and the community. It is a Python 3.7+ implementation of the

Language Server Protocol ↗ (versions <1.4 should still work with Python 3.6).

Installation instructions can be found in the project’s README ↗, but it consists of installing a package using pip (or pipx ↗):

Terminal window
pip install -U 'python-lsp-server[all]'

The [all] above refers to the optional providers supported. You can fine-tune what to install following the instructions here ↗.

pylsp-mypy

python-lsp/pylsp-mypy ↗ (pylsp-mypy) is a Mypy (type checker) plugin for Pylsp. First do the steps in Pylsp section and then install pylsp-mypy:

Terminal window
pip install pylsp-mypy

languages.toml

[[language]]
name = "python"
language-servers = ["pylsp"]


[language-server.pylsp.config.pylsp]
plugins.pylsp_mypy.enabled = true
plugins.pylsp_mypy.live_mode = true

python-lsp-ruff

python-lsp/python-lsp-ruff ↗ is a plugin for pylsp that provides support for ruff (see below).

See installation instructions ↗.

The plugin supports some configuration ↗, but it should work out of the box after installing.

pyright

Pyright is a fast type checker and language server from Microsoft, meant for large Python source bases. It is the LSP part of pylance (the VS Code python daemon).

https://github.com/microsoft/pyright ↗

The language server can be installed by running npm install --location=global pyright

languages.toml

[[language]]
name = "python"
language-servers = [ "pyright" ]

basedpyright

Basedpyright is a fork of pyright with various type checking improvements, improved vscode support and pylance features built into the language server.

https://docs.basedpyright.com ↗

The language server can be installed by running pip install basedpyright

languages.toml

[[language]]
name = "python"
language-servers = [ "basedpyright" ]

ruff

charliermarsh/ruff ↗ is an extremely fast Python linter, written in Rust (see installation instructions ↗).

An LSP for it is available through ruff-lsp ↗ (see installation instructions ↗) or ruff ↗ with arg server. Also check out the ruff docs for integration with helix ↗.

A suggested Helix configuration using ruff as lsp is given below:

[language-server.ruff-lsp]
command = "ruff-lsp"
[[language]]
name = "python"
language-servers = [ "ruff-lsp" ]

or

[[language]]
name = "python"
language-servers = [ "ruff" ]
auto-format = true
[language-server.ruff]
command = "ruff"
args = ["server"]

Note that ruff lacks basic features and is meant to be used alongside another LSP (helix-editor/helix#5399 (comment) ↗, charliermarsh/ruff-lsp#23 ↗, charliermarsh/ruff-lsp#23 (comment) ↗).

As an alternative, pylsp has support for ruff via a plugin. See instructions for Helix here

pyright + ruff

pyright ↗ - npm install pyright -g

ruff-lsp ↗ - pip install ruff-lsp or ruff ↗ - pip install ruff (ruff-lsp is A Language Server Protocol ↗ implementation for ruff, you can choose one)

[[language]]
name = "python"
language-servers = [ "pyright", "ruff" ]


[language-server.pyright.config.python.analysis]
typeCheckingMode = "basic"


## if you choose `ruff-lsp`
[language-server.ruff]
command = "ruff-lsp"
[language-server.ruff.config.settings]
args = ["--ignore", "E501"]
## if you choose `ruff` itself
[language-server.ruff]
command = "ruff"
args = ["server"]

ruff + pyright + pylyzer

## in languages.toml
[[language]]
name = "python"
language-servers = ["pyright", "ruff", "pylyzer"]
[language-server.pyright.config.python.analysis]
typeCheckingMode = "basic"
[language-server.ruff]
command = "ruff"
args = ["server"]
[language-server.pylyzer]
command = "pylyzer"
args = ["--server"]

R

An implementation of the Language Server Protocol for R.

https://github.com/REditorSupport/languageserver ↗

The language server can be installed by running R -e 'install.packages("languageserver")'.

Racket

https://github.com/jeapostrophe/racket-langserver ↗

The Racket language server. This project seeks to use DrRacket ↗’s public API to provide functionality that mimics DrRacket’s code tools as closely as possible.

Install via raco: raco pkg install racket-langserver

ReScript

https://github.com/rescript-lang/rescript-vscode ↗

// ReScript language server.

Rust

rust-analyzer ↗, a language server for Rust.

You can install rust-analyzer using rustup starting from Rust 1.64, and it will be added to your system’s $PATH starting from Rustup 1.26.0 ↗:

Terminal window
rustup component add rust-analyzer

Add the following to your languages.toml to enable clippy ↗ on save:

[language-server.rust-analyzer.config.check]
command = "clippy"

See docs ↗ for extra settings. Everything under the rust-analyzer key goes under language-server.rust-analyzer.config key in helix (for example, rust-analyzer.check.command = "clippy" is translated into the language.toml as above.)

Scala

Scala language server with rich IDE features.

https://scalameta.org/metals/ ↗

  1. Install Coursier ↗
  2. Run coursier install metals

Scheme

Steel Dialect

Steel’s language server is available at github.com/mattwparas/crates/steel-language-server ↗.

Recommended installation for LSP + interpreter (link ↗):

Terminal window
git clone git@github.com:mattwparas/steel.git
cd steel
cargo xtask install

Then follow the configuration ↗ instructions.

Finally, add the following to your language configuration file:

[[language]]
name = "scheme"
language-servers = ["steel-language-server"]


[language-server.steel-language-server]
command = "steel-language-server"
args = []

SCSS

SCSS’s language server is available from the vscode-langservers-extracted collection:

https://github.com/hrsh7th/vscode-langservers-extracted ↗

You may install it by running:

Terminal window
npm i -g vscode-langservers-extracted

Slint

LSP ↗

slint ↗

Terminal window
cargo install slint-lsp

Smithy

For Smithy projects the following LSP is used: https://github.com/awslabs/smithy-language-server ↗

coursier ↗ must be installed so that the language server can be launched. To install coursier please see their installation instructions ↗. Since coursier will take care of everything else, no other steps are necessary!

Solargraph

https://solargraph.org/ ↗

Solargraph, a language server for Ruby

You can install Solargraph via gem install.

Terminal window
gem install --user-install solargraph

solc

solc is the native language server for the Solidity language.

https://docs.soliditylang.org/en/latest/installing-solidity.html ↗

Svelte

https://github.com/sveltejs/language-tools/tree/master/packages/language-server ↗

svelte-language-server can be installed via npm:

Terminal window
npm i -g svelte-language-server

For integration with .js and .ts files install typescript-svelte-plugin via npm:

Terminal window
npm i -g typescript-svelte-plugin

Then for each svelte project update your tsconfig.json/jsconfig.json to add the typescript-svelte-plugin

{
    "compilerOptions": {
        ...
        "plugins": [{
            "name": "typescript-svelte-plugin"
        }]
    }
}

Further information on js and ts integration for svelte can be found here ↗.

Swift

A language server for Swift, formatting provided via swift-format

https://github.com/apple/sourcekit-lsp ↗

https://github.com/apple/swift-format ↗

Follow the Getting Started ↗ guide to get sourcekit-lsp installed correctly for your OS. No additional configuration is needed, though note to use the same toolchain for both your installed LSP, and that you use to build.

Sql

https://github.com/joe-re/sql-language-server ↗

Terminal window
npm i -g sql-language-server

languages.toml setting

[language-server.sql-language-server]
command = "sql-language-server"
args = ["up", "--method", "stdio"]


[[language]]
name = "sql"
language-servers = [ "sql-language-server" ]

TailwindCSS

https://github.com/tailwindlabs/tailwindcss-intellisense ↗

tailwindcss-language-server can be installed via npm:

Terminal window
npm i -g @tailwindcss/language-server

Add this to your local languages.toml file to enable it

languages.toml:

[[language]]
name = "html"
language-servers = [ "vscode-html-language-server", "tailwindcss-ls" ]


[[language]]
name = "css"
language-servers = [ "vscode-css-language-server", "tailwindcss-ls" ]


[[language]]
name = "jsx"
language-servers = [ "typescript-language-server", "tailwindcss-ls" ]


[[language]]
name = "tsx"
language-servers = [ "typescript-language-server", "tailwindcss-ls" ]


[[language]]
name = "svelte"
language-servers = [ "svelteserver", "tailwindcss-ls" ]

If you want to use TailwindCSS language server with other languages, configure like example below. The example is with rust.

[[language]]
name = "rust"
language-servers = ["rust-analyzer", "tailwindcss-ls"]


[language-server.tailwindcss-ls]
config = { userLanguages = { rust = "html", "*.rs" = "html" } }

Terraform

You’ll need terraform-ls installed; the instructions are here ↗.

Add this to your local languages.toml file to enable it

languages.toml:

[[language]]
name = "hcl"
language-servers = [ "terraform-ls" ]
language-id = "terraform"


[[language]]
name = "tfvars"
language-servers = [ "terraform-ls" ]
language-id = "terraform-vars"


[language-server.terraform-ls]
command = "terraform-ls"
args = ["serve"]

TOML

https://taplo.tamasfe.dev/ ↗

The NPM versions of taplo does not contain the language server at this time The full version (with the language server) can be downloaded from:

binaries: taplo releases ↗

or installed with:

cargo:

Terminal window
cargo install taplo-cli --locked --features lsp

languages.toml:

[[language]]
name = "toml"
formatter = { command = "taplo", args = ["fmt", "-"] }

Run taplo lsp --help for more info.

TypeScript

typescript-language-server

https://github.com/typescript-language-server/typescript-language-server ↗

typescript-language-server depends on typescript. Both packages can be installed via npm:

Terminal window
npm install -g typescript typescript-language-server

To configure type language server, add a tsconfig.json ↗ or jsconfig.json ↗ to the root of your project.

Here’s an example that disables type checking in JavaScript files.

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es6",
    "checkJs": false
  },
  "exclude": ["node_modules"]
}

Biome

Biome is a fast and efficient toolchain for web development that formats and lints code, supporting JavaScript, TypeScript, JSX, and JSON, with over 190 rules and high compatibility with existing tools like Prettier.

Terminal window
npm install --save-dev --save-exact @biomejs/biome

Follow the official instructions on how to configure Biome for Helix ↗.

ESLint

[!important] @4.10 is broken for hx. You can:

  1. Install the LSP:
Terminal window
npm i -g vscode-langservers-extracted@4.8
## `npm update -g` will install the latest non-major version,
## only do that after the issue has been fixed!
## Unfortunately, there's no known way to pin/lock
## global packs
  1. Add this to your languages.toml:
## You might want to read this:
## https://github.com/helix-editor/helix/discussions/8452


[[language]]
name = "javascript"
language-servers = [
  "typescript-language-server", # optional
  "vscode-eslint-language-server",
]


[[language]]
name = "typescript"
language-servers = [
  "typescript-language-server",
  "vscode-eslint-language-server",
]
  1. Install ESL ↗

TypeSpec

typespec ↗

The language server is installed along with the compiler using npm:

Terminal window
npm install -g @typespec/compiler

Typst

typst ↗

Terminal window
cargo install --git https://github.com/nvarner/typst-lsp typst-lsp

Uiua

[language-server.uiua-lsp]
command = "uiua"
args = ["lsp"]


[[language]]
name = "uiua"
scope = "source.uiua"
injection-regex = "uiua"
file-types = ["ua"]
roots = []
auto-format = true
comment-token = "#"
language-servers = [ "uiua-lsp" ]
indent = { tab-width = 2, unit = "  " }
shebangs = ["uiua"]
auto-pairs = {'(' = ')', '{' = '}', '[' = ']', '"' = '"'}

Unison

Unison language server.

More info: https://github.com/unisonweb/unison/blob/trunk/docs/language-server.markdown ↗

Requirements:

  • ucm started
  • ncat, nc or netcat

To ~/.config/helix/languages.toml append this code:

[language-server.ucm]
command = "ncat"
args = ["localhost", "5757"]


[[language]]
name = "unison"
language-servers = [ "ucm" ]

V

https://github.com/vlang/v-analyzer ↗

Clone, install and build:

Terminal window
git clone --filter=blob:none --recursive --shallow-submodules https://github.com/vlang/v-analyzer
cd v-analyzer
v build.vsh release

or use the installer, and follow the instructions that it will print: v -e "$(curl -fsSL https://raw.githubusercontent.com/vlang/v-analyzer/main/install.vsh)"

config path:

set the v-analyzer to environment variable:

Terminal window
PATH=your/path/v-analyzer/bin:$PATH

Vue

https://github.com/vuejs/language-tools/tree/master/packages/language-server ↗

The Vue language server vue-language-server can be installed via npm:

Terminal window
npm i -g @vue/language-server

To autoformat your .vue files upon save, you can first install prettier via npm:

Terminal window
npm i -g prettier

And then add this to your languages.toml file in your Helix configuration directory:

[[language]]
name = "vue"
auto-format = true
formatter = { command = "prettier", args = ["--parser", "vue"] }
language-servers = ["typescript-language-server"]


[[language-server.typescript-language-server.config.plugins]]
name = "@vue/typescript-plugin"
location = <path to "node_modules/@vue/language-server/">
languages = ["vue"]

WGSL

https://github.com/wgsl-analyzer/wgsl-analyzer ↗

wgsl_analyzer can be installed via cargo:

Terminal window
cargo install --git https://github.com/wgsl-analyzer/wgsl-analyzer wgsl_analyzer

XML

https://github.com/redhat-developer/vscode-xml ↗

wget https://github.com/redhat-developer/vscode-xml/releases/download/0.27.1/lemminx-linux.zip ↗

  1. Download lemminx-linux.zip
  2. Extract and copy lemminx-linux binary to location in $PATH
  3. Install xmllint via package manger yay, dnf, pacman apt-get etc (rpm: dnf install libxml2)

Configuration:

[[language]]
name = "xml"
file-types = [ "xml", "svg", "xsd", "xslt", "xsl" ]
auto-format = true
formatter = { command = "xmllint", args = ["--format", "-"] }
language-servers = [ "xml" ]


[language-server.xml]
command = "lemminx-linux"

YAML

https://github.com/redhat-developer/yaml-language-server ↗

yaml-language-server can be installed via brew on Mac:

Terminal window
brew install yaml-language-server

or via npm:

Terminal window
npm i -g yaml-language-server@next

Example configuration using json schemas.

[language-server.yaml-language-server.config.yaml]
format = { enable = true }
validation = true


[language-server.yaml-language-server.config.yaml.schemas]
"https://json.schemastore.org/github-workflow.json" = ".github/workflows/*.{yml,yaml}"
"https://raw.githubusercontent.com/ansible-community/schemas/main/f/ansible-tasks.json" = "roles/{tasks,handlers}/*.{yml,yaml}"

Zig

Zig LSP implementation + Zig Language Server.

https://github.com/zigtools/zls ↗

Other Language Server Protocol Types

Non language-specific Language Server Protocols, non-coding LSPs, and others.

Harper-ls

Harper ↗ is an English grammar and spelling checker for comments and text. Installing:

Terminal window
cargo install harper-ls --locked

Harper will need to be manually added to each language you’d like check’s language server list. Usage:

[language-server.harper-ls]
command = "harper-ls"
args = ["--stdio"]

Disabling specific linters ↗.

[language-server.harper-ls.config.harper-ls.linters]
spaces = false

Vale-ls

Vale is a markup-aware linter for prose built with speed and extensibility in mind.

https://github.com/errata-ai/vale ↗

ToolExtensibleChecksSupports MarkupBuilt WithLicense
ValeYes (via YAML)spelling, styleYes (Markdown, AsciiDoc, reStructuredText, HTML, XML, Org)GoMIT

The Vale Language Server is an implementation of the Language Server Protocol for Vale.

https://github.com/errata-ai/vale-ls ↗

Vale supports linting source code comments in a number of languages ↗

You must install both vale and vale-ls into your $PATH and add it to each language you wish to lint, for example:

Since https://github.com/helix-editor/helix/pull/11636/ ↗ you only need to add:

[[language]]
name = "html"
language-servers = [ "vscode-html-language-server", "vale-ls" ]

Before that PR:

languages.toml

[language-server.vale-ls]
command = "vale-ls"


[[language]]
name = "html"
language-servers = [ "vscode-html-language-server", "vale-ls" ]