Skip to content

Language Servers#

Follow the setup steps for a language server to get it up and running.

If you encounter problems, consult the common issues page or search the LSP issues before opening new ones.

If there are no setup steps for a language server on this page, but a language server implementation exist, follow the guide for creating a client configuration. Pull requests for adding a new client configuration are welcome.

We recommend installing LSP-json.

LSP-json provides completions and diagnostics when editing JSON files that adhere to a JSON schema.

Angular#

Follow installation instructions on LSP-angular.

Bash#

Follow installation instructions on LSP-bash.

C/C++#

See the dedicated C/C++ guide for using ccls or clangd.

C##

  1. Download a .NET SDK. The ".NET Core" SDK is known to not work on macOS.
  2. If on macOS/Linux, download the Mono Runtime in order to be able to run .NET executables and DLLs.
  3. Download omnisharp.
  4. Open Preferences > Package Settings > LSP > Settings and add the "omnisharp" client configuration to the "clients":
{
    "clients": {
        "omnisharp": {
            "enabled": true,
            "command": [
                "mono", // mono is only necessary for macOS/Linux
                "/home/tb/prebuilt/omnisharp/OmniSharp.exe",
                "-lsp"
            ],
            "env": {
                // This may or may not be necessary, please report your findings!
                "FrameworkPathOverride": "/path/to/omnisharp/.msbuild/Current"
            },
            "selector": "source.cs"
        }
    }
}
{
    "clients": {
        "omnisharp": {
            "enabled": true,
            "command": [
                "mono", // mono is only necessary for macOS/Linux
                "/home/tb/prebuilt/omnisharp/OmniSharp.exe",
                "-lsp"
            ],
            "env": {
                // This may or may not be necessary, please report your findings!
                "FrameworkPathOverride": "/path/to/omnisharp/.msbuild/Current"
            },
            "languageId": "csharp",
            "scopes": ["source.cs"],
            "syntaxes": ["Packages/C#/C#.sublime-syntax"]
        }
    }
}

Clojure#

  1. Download clojure-lsp.
  2. Open Preferences > Package Settings > LSP > Settings and add the "clojure-lsp" client configuration to the "clients":
{
    "clients": {
        "clojure-lsp": {
            "enabled": true,
            "command": ["java", "-jar", "/PATH/TO/clojure-lsp"], // Update the PATH
            "selector": "source.clojure",
            "initializationOptions": {}
        }
    }
}
{
    "clients": {
        "clojure-lsp": {
            "enabled": true,
            "command": ["java", "-jar", "/PATH/TO/clojure-lsp"], // Update the PATH
            "languageId": "clojure",
            "scopes": ["source.clojure"],
            "syntaxes": ["Packages/Clojure/Clojure.sublime-syntax"],
            "initializationOptions": {}
        }
    }
}

See available initializationOptions.

CSS#

Follow installation instructions on LSP-css.

D#

  1. Install the D Language Server.
  2. Open Preferences > Package Settings > LSP > Settings and add the "dls" client configuration to the "clients":
{
    "clients": {
        "dls": {
            "enabled": true,
            "command": ["/PATH/TO/DLS_EXECUTABLE"], // Update the PATH
            "selector": "source.d"
        }
    }
}
{
    "clients": {
        "dls": {
            "enabled": true,
            "command": ["/PATH/TO/DLS_EXECUTABLE"], // Update the PATH
            "languageId": "d",
            "scopes": ["source.d"],
            "syntaxes": ["Packages/D/D.sublime-syntax"]
        }
    }
}

Dart#

Follow installation instructions on LSP-Dart.

Dockerfile#

Follow installation instructions on LSP-dockerfile.

Elixir#

Follow installation instructions on LSP-elixir.

Elm#

Follow installation instructions on LSP-elm.

Erlang#

  1. Install the Erlang Language Server.
  2. Open Preferences > Package Settings > LSP > Settings and add the "erlang-ls" client configuration to the "clients":
{
    "clients": {
        "erlang-ls": {
            "enabled": true,
            "command": [ "/PATH/TO/erlang_ls", "--transport", "stdio" ], // Update the PATH
            "selector": "source.erlang"
        }
    }
}
{
    "clients": {
        "erlang-ls": {
            "enabled": true,
            "command": [ "/path/to/my/erlang_ls", "--transport", "stdio" ],
            "languageId": "erlang",
            "scopes": [ "source.erlang" ],
            "syntaxes": ["Packages/Erlang/Erlang.sublime-syntax"]
        }
    }
}

ESLint#

Follow installation instructions on LSP-eslint.

Flow#

  1. Install flow.
  2. Open Preferences > Package Settings > LSP > Settings and add the "flow" client configuration to the "clients":
{
    "clients": {
        "flow": {
            "enabled": true,
            "command": ["flow", "lsp"],
            "selector": "source.js | source.js.react"
        }
    }
}
{
    "clients": {
        "flow": {
            "enabled": true,
            "command": ["flow", "lsp"],
            "languageId": "javascript",
            "scopes": ["source.js"],
            "syntaxes": ["Packages/Babel/JavaScript (Babel).sublime-syntax", "Packages/JavaScript/JavaScript.sublime-syntax"]
        }
    }
}

Fortran#

  1. Install the Fortran package from Package Control for syntax highlighting.
  2. Install the Fortran Language Server.
  3. Open Preferences > Package Settings > LSP > Settings and add the "fortls" client configuration to the "clients":
{
    "clients": {
        "fortls": {
            "enabled": true,
            "command": ["fortls"],
            "selector": "source.modern-fortran | source.fixedform-fortran"
        }
    }
}
{
    "clients": {
        "fortls": {
            "enabled": true,
            "command": ["fortls"],
            "languageId": "fortran",
            "scopes": ["source.modern-fortran", "source.fixedform-fortran"],
            "syntaxes": [
                "Packages/Fortran/grammars/FortranModern.sublime-syntax",
                "Packages/Fortran/grammars/FortranFixedForm.sublime-syntax"
            ]
        }
    }
}

See available configuration options.

For example set "command": ["fortls", "--lowercase_intrinsics"] to use lowercase for autocomplete suggestions.

Go#

  1. Install gopls.
  2. Open Preferences > Package Settings > LSP > Settings and add the "gopls" client configuration to the "clients":
{
    "clients": {
        "gopls": {
            "enabled": true,
            "command": ["gopls"],
            "selector": "source.go",
            "initializationOptions": {
                "experimentalWorkspaceModule": false
            }
        }
    }
}
{
    "clients": {
        "gopls": {
            "enabled": true,
            "command": ["gopls"],
            "languageId": "go",
            "scopes": ["source.go"],
            "syntaxes": [
                "Packages/Go/Go.sublime-syntax",
                "Packages/GoSublime/syntax/GoSublime-Go-Recommended.sublime-syntax"
            ],
            "initializationOptions": {
                "experimentalWorkspaceModule": false
            }
        },
    }
}

Visit gopls repo for more info.

Enable multi-module workspace support by setting the experimentalWorkspaceModule to true. Most features will work across modules, but some, such as goimports, will not work as expected. Please note that this setting is still very experimental.

GraphQL#

Follow installation instructions on LSP-graphql.

Haskell#

  1. Install haskell-language-server.
  2. Open Preferences > Package Settings > LSP > Settings and add the "haskell-language-server" client configuration to the "clients":
{
    "clients": {
        "haskell-language-server": {
            "enabled": true,
            "command": ["haskell-language-server-wrapper", "--lsp"],
            "selector": "source.haskell"
        }
    }
}
{
    "clients": {
        "haskell-language-server": {
            "enabled": true,
            "command": ["haskell-language-server-wrapper", "--lsp"],
            "languageId": "haskell",
            "scopes": ["source.haskell"],
            "syntaxes": ["Packages/Haskell/Haskell.sublime-syntax"]
        }
    }
}

HTML#

Follow installation instructions on LSP-html.

Java#

  1. Download and extract Eclipse's jdt-ls.
  2. Open Preferences > Package Settings > LSP > Settings and add the "jdtls" client configuration to the "clients":
{
    "clients": {
        "jdtls": {
            "enabled": true,
            "command": [
                "java",
                "--add-modules=ALL-SYSTEM",
                "--add-opens",
                "java.base/java.util=ALL-UNNAMED",
                "--add-opens",
                "java.base/java.lang=ALL-UNNAMED",
                "-Declipse.application=org.eclipse.jdt.ls.core.id1",
                "-Dosgi.bundles.defaultStartLevel=4",
                "-Declipse.product=org.eclipse.jdt.ls.core.product",
                "-Dfile.encoding=UTF-8",
                "-DwatchParentProcess={true|false}",  // false on windows, true other OSs
                "-noverify",
                "-Xmx1G",
                "-XX:+UseG1GC",
                "-XX:+UseStringDeduplication",
                "-jar",
                "PATH/TO/jdt-language-server-latest/plugins/org.eclipse.equinox.launcher_*.jar" // 1. replace the PATH/TO with your own 2. replace * with the file version
                "-configuration",
                "PATH/TO/jdt-language-server-latest/config_{win|mac|linux}", // 1. replace the PATH/TO with your own 2. choose the config folder based on the OS
                "-data",
                "<TEMP_DIR>/${project_base_name}/jdt_ws" // replace <TEMP_DIR> with the temp folder in your system. macOS: echo $TMPDIR
            ],
            "selector": "source.java"
        }
    }
}
{
    "clients": {
        "jdtls": {
            "enabled": true,
            "command": [
                "java",
                "--add-modules=ALL-SYSTEM",
                "--add-opens",
                "java.base/java.util=ALL-UNNAMED",
                "--add-opens",
                "java.base/java.lang=ALL-UNNAMED",
                "-Declipse.application=org.eclipse.jdt.ls.core.id1",
                "-Dosgi.bundles.defaultStartLevel=4",
                "-Declipse.product=org.eclipse.jdt.ls.core.product",
                "-Dfile.encoding=UTF-8",
                "-DwatchParentProcess={true|false}",  // false on windows, true other OSs
                "-noverify",
                "-Xmx1G",
                "-XX:+UseG1GC",
                "-XX:+UseStringDeduplication",
                "-jar",
                "PATH/TO/jdt-language-server-latest/plugins/org.eclipse.equinox.launcher_*.jar" // 1. replace the PATH/TO with your own 2. replace * with the file version
                "-configuration",
                "PATH/TO/jdt-language-server-latest/config_{win|mac|linux}", // 1. replace the PATH/TO with your own 2. choose the config folder based on the OS
                "-data",
                "<TEMP_DIR>/${project_base_name}/jdt_ws" // replace <TEMP_DIR> with the temp folder in your system. macOS: echo $TMPDIR
            ],
            "languageId": "java",
            "scopes": ["source.java"],
            "syntaxes": ["Packages/Java/Java.sublime-syntax"]
        }
    }
}

JSON#

Follow installation instructions on LSP-json.

Julia#

  1. Install the Julia package from Package Control for syntax highlighting.
  2. Install the LanguageServer and SymbolServer packages from the Julia REPL:

    import Pkg;
    Pkg.add("LanguageServer")
    Pkg.add("SymbolServer")
    
  3. Open Preferences > Package Settings > LSP > Settings and add the "julials" client configuration to the "clients":

{
    "clients": {
        "julials": {
            "enabled": true,
            "command": ["bash", "PATH_TO_JULIA_SERVER/LanguageServer/contrib/languageserver.sh"], // on Linux/macOS
          // "command": ["julia", "--startup-file=no", "--history-file=no", "-e", "using Pkg; using LanguageServer; using LanguageServer.SymbolServer; env_path=dirname(Pkg.Types.Context().env.project_file); server=LanguageServer.LanguageServerInstance(stdin,stdout,false,env_path); run(server)"], // on Windows
            "selector": "source.julia",
            "settings": {
                // Default values from VS Code:
                "julia.format.calls": true,      // Format function calls
                "julia.format.comments": true,   // Format comments
                "julia.format.curly": true,      // Format braces
                "julia.format.docs": true,       // Format inline documentation
                "julia.format.indent": 4,        // Indent size for formatting
                "julia.format.indents": true,    // Format file indents
                "julia.format.iterOps": true,    // Format loop iterators
                "julia.format.kw": true,         // Remove spaces around = in function keywords
                "julia.format.lineends": false,  // [undocumented]
                "julia.format.ops": true,        // Format whitespace around operators
                "julia.format.tuples": true,     // Format tuples
                "julia.lint.call": false,        // Check calls against existing methods (experimental)
                "julia.lint.constif": true,      // Check for constant conditionals of if statements
                "julia.lint.datadecl": false,    // [undocumented]
                "julia.lint.iter": true,         // Check iterator syntax of loops
                "julia.lint.lazy": true,         // Check for deterministic lazy boolean operators
                "julia.lint.modname": true,      // Check for invalid submodule names
                "julia.lint.nothingcomp": false, // [undocumented]
                "julia.lint.pirates": true,      // Check for type piracy
                "julia.lint.run": true,          // run the linter on active files
                "julia.lint.typeparam": true     // Check for unused DataType parameters
            }
        }
    }
}
{
    "clients": {
        "julials": {
            "enabled": true,
            "command": ["bash", "PATH_TO_JULIA_SERVER/LanguageServer/contrib/languageserver.sh"], // on Linux/macOS
          // "command": ["julia", "--startup-file=no", "--history-file=no", "-e", "using Pkg; using LanguageServer; using LanguageServer.SymbolServer; env_path=dirname(Pkg.Types.Context().env.project_file); server=LanguageServer.LanguageServerInstance(stdin,stdout,false,env_path); run(server)"], // on Windows
            "languageId": "julia",
            "scopes": ["source.julia"],
            "syntaxes": ["Packages/Julia/Julia.sublime-syntax"],
            "settings": {
                // Default values from VS Code:
                "julia.format.calls": true,      // Format function calls
                "julia.format.comments": true,   // Format comments
                "julia.format.curly": true,      // Format braces
                "julia.format.docs": true,       // Format inline documentation
                "julia.format.indent": 4,        // Indent size for formatting
                "julia.format.indents": true,    // Format file indents
                "julia.format.iterOps": true,    // Format loop iterators
                "julia.format.kw": true,         // Remove spaces around = in function keywords
                "julia.format.lineends": false,  // [undocumented]
                "julia.format.ops": true,        // Format whitespace around operators
                "julia.format.tuples": true,     // Format tuples
                "julia.lint.call": false,        // Check calls against existing methods (experimental)
                "julia.lint.constif": true,      // Check for constant conditionals of if statements
                "julia.lint.datadecl": false,    // [undocumented]
                "julia.lint.iter": true,         // Check iterator syntax of loops
                "julia.lint.lazy": true,         // Check for deterministic lazy boolean operators
                "julia.lint.modname": true,      // Check for invalid submodule names
                "julia.lint.nothingcomp": false, // [undocumented]
                "julia.lint.pirates": true,      // Check for type piracy
                "julia.lint.run": true,          // run the linter on active files
                "julia.lint.typeparam": true     // Check for unused DataType parameters
            }
        }
    }
}

Kotlin#

  1. Install the Kotlin package from Package Control for syntax highlighting.
  2. Install the Kotlin Language Server (requires building first).
  3. Open Preferences > Package Settings > LSP > Settings and add the "kotlinls" client configuration to the "clients":
{
    "clients": {
        "kotlinls": {
            "enabled": true,
            "command": ["PATH/TO/KotlinLanguageServer/build/install/kotlin-language-server/bin/kotlin-language-server.bat"], // Update the PATH
            "selector": "source.Kotlin",
            "settings": {
                "kotlin": {
                    // put your server settings here
                }
            }
        }
    }
}
{
    "clients": {
        "kotlinls": {
            "enabled": true,
            "command": ["PATH/TO/KotlinLanguageServer/build/install/kotlin-language-server/bin/kotlin-language-server.bat"], // Update the PATH
            "languageId": "kotlin",
            "scopes": ["source.Kotlin"],
            "syntaxes": ["Packages/kotlin/Kotlin.tmLanguage"],
            "settings": {
                "kotlin": {
                    // put your server settings here
                }
            }
        }
    }
}

LaTeX#

Instructions for Sublime Text 4.

Follow installation instructions on LSP-TexLab.


Instructions for Sublime Text 3.

  1. Download the binary.
  2. Open Preferences > Package Settings > LSP > Settings and add the "texlab" client configuration to the "clients":
{
    "clients": {
        "texlab": {
            "enabled": true,
            "command": ["PATH/TO/texlab"], // Update the PATH
            "languages": [{
                "languageId": "latex",
                "document_selector": "text.tex.latex"
            }, {
                "languageId": "bibtex",
                "document_selector": "text.bibtex"
            }]
        }
    }
}

For further requirements see the TexLab Docs.

Lisp#

  1. Install cc-lsp using Roswell.
  2. Open Preferences > Package Settings > LSP > Settings and add the "cc-lsp" client configuration to the "clients":
{
    "clients": {
        "cc-lsp": {
            "enabled": true,
            "command": ["cl-lsp", "stdio"],
            "selector": "source.lisp"
        }
    }
}
{
    "clients": {
        "cc-lsp": {
            "enabled": true,
            "command": ["cl-lsp", "stdio"],
            "languageId": "lisp",
            "scopes": ["source.lisp"],
            "syntaxes": ["Packages/Lisp/Lisp.sublime-syntax"]
        }
    }
}

Lua#

  1. Download the VS Code extension.
  2. Open Preferences > Package Settings > LSP > Settings and add the "lua-ls" client configuration to the "clients":
{
    "clients": {
        "lua-ls": {
            "enabled": true,
            "command": [
                "PATH/TO/sumneko.lua-#.#.#/extension/server/bin/lua-language-server", // Update the PATH
                "-E", "PATH/TO/sumneko.lua-#.#.#/extension/server/main.lua"
            ],
            "selector": "source.lua"
        }
    }
}
{
    "clients": {
        "lua-ls": {
            "enabled": true,
            "command": [
                "PATH/TO/sumneko.lua-#.#.#/extension/server/bin/lua-language-server", // Update the PATH
                "-E", "PATH/TO/sumneko.lua-#.#.#/extension/server/main.lua"
            ],
            "languageId": "lua",
            "scopes": ["source.lua"],
            "syntaxes": ["Packages/Lua/Lua.sublime-syntax"]
        }
    }
}

OCaml/Reason#

  1. Install the Reason package from Package Control for syntax highlighting.
  2. Install the Reason Language Server.
  3. Open Preferences > Package Settings > LSP > Settings and add the "reason" client configuration to the "clients":
{
    "clients": {
        "reason": {
            "enabled": true,
            "command": ["PATH/TO/reason-language-server.exe"], // Update the PATH
            "selector": "source.ocaml | source.reason"
        }
    }
}
{
    "clients": {
        "reason": {
            "enabled": true,
            "command": ["PATH/TO/reason-language-server.exe"], // Update the PATH
            "languageId": "reason",
            "scopes": ["source.ocaml", "source.reason"],
            "syntaxes": [
                "Packages/Ocaml/OCaml.sublime-syntax",
                "Packages/Reason/Reason.tmLanguage",
                "Packages/sublime-reason/Reason.tmLanguage"
            ]
        }
    }
}

PromQL#

Follow installation instructions on LSP-promql.

PHP#

There are multiple options:

Intelephense#

Follow installation instructions on LSP-intelephense.

Serenata#

Follow installation instructions on LSP-serenata.

PowerShell#

  1. Install the PowerShell package from Package Control for syntax highlighting.
  2. Download and extract the latest release PowerShellEditorServices.
  3. Make sure PowerShell help files are up to date by running Update-Help in the PowerShell console (the one you're using in the command below).
  4. Open Preferences > Package Settings > LSP > Settings and add the "powershell-ls" client configuration to the "clients":
{
    "clients": {
        "powershell-ls": {
            "enabled": true,
            "command": [
                "powershell", // or pwsh for PowerShell Core
                "-NoLogo",
                "-NoProfile",
                "-NonInteractive",
                "-ExecutionPolicy", "Bypass", // Windows only
                "-Command", "PATH/TO/PowerShellEditorServices/PowerShellEditorServices/Start-EditorServices.ps1",
                "-LogPath", "PATH/TO/pses.log", // specify a path where a logfile should be stored
                "-LogLevel", "Normal",
                "-SessionDetailsPath", "PATH/TO/session.json", // specify a path where a file for session details should be stored
                "-FeatureFlags", "@()",
                "-HostName", "'Sublime Text'",
                "-HostProfileId", "subl",
                "-HostVersion", "1.0.0",
                "-AdditionalModules", "@()",
                "-BundledModulesPath", "PATH/TO/PowerShellEditorServices",
                "-Stdio"
            ],
            "selector": "source.powershell"
        }
    }
}
{
    "clients": {
        "powershell-ls": {
            "enabled": true,
            "command": [
                "powershell", // or pwsh for PowerShell Core
                "-NoLogo",
                "-NoProfile",
                "-NonInteractive",
                "-ExecutionPolicy", "Bypass", // Windows only
                "-Command", "PATH/TO/PowerShellEditorServices/PowerShellEditorServices/Start-EditorServices.ps1",
                "-LogPath", "PATH/TO/pses.log", // specify a path where a logfile should be stored
                "-LogLevel", "Normal",
                "-SessionDetailsPath", "PATH/TO/session.json", // specify a path where a file for session details should be stored
                "-FeatureFlags", "@()",
                "-HostName", "'Sublime Text'",
                "-HostProfileId", "subl",
                "-HostVersion", "1.0.0",
                "-AdditionalModules", "@()",
                "-BundledModulesPath", "PATH/TO/PowerShellEditorServices",
                "-Stdio"
            ],
            "languageId": "powershell",
            "scopes": ["source.powershell"],
            "syntaxes": ["Packages/PowerShell/Support/PowershellSyntax.tmLanguage"]
        }
    }
}

For more details see this issue.

Python#

There are multiple options:

Pyright#

Follow installation instructions on LSP-pyright.

Python LSP Server#

pip install 'python-lsp-server[all]'

Make sure you can run pylsp in your terminal. If you've installed it into a virtualenv, you might need to override the path to pylsp in global LSP settings (Package Settings -> LSP -> Settings):

{
    "clients": {
        "pylsp": {
            "enabled": true,
            "command": ["pylsp"],
            // "command": ["/Users/mike/.virtualenvs/pylsp-virtual-env/bin/pylsp"], // example path, adjust it for your use case
            "selector": "source.python"
        }
    }
}
{
    "clients": {
        "pylsp": {
            "enabled": true,
            "command": ["pylsp"],
            // "command": ["/Users/mike/.virtualenvs/pylsp-virtual-env/bin/pylsp"], // example path, adjust it for your use case
            "languageId": "python",
            "scopes": ["source.python"],
            "syntaxes": ["Packages/Python/Python.sublime-syntax", "Packages/MagicPython/grammars/MagicPython.tmLanguage", "Packages/Djaneiro/Syntaxes/Python Django.tmLanguage"]
        }
    }
}

If you use a virtualenv for your current project, add a path to it in your project configuration (Project -> Edit Project):

{
    "settings": {
        "LSP": {
            "pylsp": {
                "enabled": true, // if you want to enable Python Language Server for current project only
                "env": {
                    // example path, adjust it for your use case
                    // it needs to be an absolute path, neither $HOME nor ~ work here
                    "PYTHONPATH": "/Users/mike/.virtualenvs/my-virtual-env/lib/python3.7/site-packages"
                }
            }
        }
    }
}

A basic configuration below can be used for bootstrapping your own:

"pylsp": {
    "enabled": true,
    "command": ["pylsp"],
    "settings": {
        "pylsp.env": {
          // Making Sublime's own libs available to the linters.
          // "PYTHONPATH": "/Applications/Sublime Text.app/Contents/MacOS/Lib/python33",
        },
        // Configuration is computed first from user configuration (in home directory),
        // overridden by configuration passed in by the language client,
        // and then overridden by configuration discovered in the workspace.
        "pylsp.configurationSources": [
          "pycodestyle", // discovered in ~/.config/pycodestyle, setup.cfg, tox.ini and pycodestyle.cfg
          // "flake8",   // discovered in ~/.config/flake8, setup.cfg, tox.ini and flake8.cfg
        ],
        "pylsp.plugins.jedi.extra_paths": [
          // The directory where the pip installation package is located
        ],
        // Enable fuzzy matches when requesting autocomplete
        "pylsp.plugins.jedi.jedi_completion.fuzzy": true,
        "pylsp.plugins.jedi.pycodestyle.enabled": true,
        "pylsp.plugins.jedi.pycodestyle.exclude": [
          // Exclude files or directories which match these patterns
        ],
        "pylsp.plugins.jedi.pycodestyle.ignore": [
          // Exclude files or directories which match these patterns
        ],
        // "pylsp.plugins.jedi.pycodestyle.maxLineLength: 80" // set maximum allowed line length
        "pylsp.plugins.pydocstyle.enabled": false,
        "pylsp.plugins.pyflakes.enabled": true,
        "pylsp.plugins.pylint.enabled": false,
        "pylsp.plugins.yapf.enabled": true,
        // pylsp' 3rd Party Plugins, Mypy type checking for Python 3, Must be installed via pip before enabling
        "pylsp.plugins.pyls_mypy.enabled": false, // Install with: pip install pyls-mypy
        "pylsp.plugins.pyls_mypy.live_mode": true
    }
}

Documentation: github:python-lsp/python-lsp-server.

List of all built-in settings.

R#

Follow installation instructions on R-IDE.

Ruby / Ruby on Rails#

There are multiple options:

Solargraph#

  1. Install solargraph.

  2. Open Preferences > Package Settings > LSP > Settings and add the "ruby" client configuration to the "clients":

{
    "clients": {
        "ruby": {
            "enabled": true,
            "command": ["solargraph", "stdio"],
            "selector": "source.ruby | text.html.ruby",
            "initializationOptions": {
                "diagnostics": false
            }
        }
    }
}
{
    "clients": {
        "ruby": {
            "enabled": true,
            "command": ["solargraph", "stdio"],
            "languageId": "ruby",
            "scopes": ["source.ruby", "source.ruby.rails", "text.html.ruby"],
            "syntaxes": [
                "Packages/Ruby/Ruby.sublime-syntax",
                "Packages/Rails/Ruby on Rails.sublime-syntax",
                "Packages/Rails/HTML (Rails).sublime-syntax"
            ],
            "initializationOptions": {
                "diagnostics": false
            }
        }
    }
}

Sorbet#

  1. Install the sorbet and sorbet-runtime gem (see github:sorbet/sorbet):

    gem install sorbet
    gem install sorbet-runtime
    

    If you have a Gemfile, using bundler, add sorbet and sorbet-runtime to your Gemfile and run:

    bundle install
    
  2. Open Preferences > Package Settings > LSP > Settings and add the "sorbet" client configuration to the "clients":

{
    "clients": {
        "sorbet": {
            "enabled": true,
            "command": ["srb", "tc", "--typed", "true", "--enable-all-experimental-lsp-features", "--lsp", "--disable-watchman"],
            "selector": "source.ruby | text.html.ruby",
        }
    }
}
{
    "clients": {
        "sorbet": {
            "enabled": true,
            "command": ["srb", "tc", "--typed", "true", "--enable-all-experimental-lsp-features", "--lsp", "--disable-watchman"],
            "languageId": "ruby",
            "scopes": ["source.ruby", "source.ruby.rails", "text.html.ruby"],
            "syntaxes": [
                "Packages/Ruby/Ruby.sublime-syntax",
                "Packages/Rails/Ruby on Rails.sublime-syntax",
                "Packages/Rails/HTML (Rails).sublime-syntax"
            ],
        }
    }
}

Rust#

There are multiple options:

Rust Analyzer#

  1. Download a binary from the release page of rust-analyzer.
  2. Rename the binary to rust-analyzer.
  3. Make sure the binary is in your $PATH.
  4. Open Preferences > Package Settings > LSP > Settings and add the "rust-analyzer" client configuration to the "clients":
{
    "clients": {
        "rust-analyzer": {
            "enabled": true,
            "command": ["rust-analyzer"],
            "selector": "source.rust"
        }
    }
}
{
    "clients": {
        "rust-analyzer": {
            "enabled": true,
            "command": ["rust-analyzer"],
            "languageId": "rust",
            "scopes": ["source.rust"],
            "syntaxes": ["Packages/Rust/Rust.sublime-syntax", "Packages/Rust Enhanced/RustEnhanced.sublime-syntax"]
        }
    }
}

Rust Enhanced#

Follow installation instructions on Rust Enhanced.

Scala#

Follow installation instructions on LSP-metals.

Stylelint#

Follow installation instructions on LSP-stylelint.

Svelte#

Follow installation instructions on LSP-svelte.

Swift#

  1. Install the Swift package from Package Control for syntax highlighting.
  2. Install Xcode 11.4 or later and ensure that xcrun -find sourcekit-lsp returns the path to sourcekit-lsp.
  3. Open Preferences > Package Settings > LSP > Settings and add the "sourcekit-lsp" client configuration to the "clients":
{
    "clients": {
        "sourcekit-lsp": {
            "enabled": true,
            "command": ["xcrun", "sourcekit-lsp"],
            "selector": "source.swift"
        }
    }
}
{
    "clients": {
        "sourcekit-lsp": {
            "enabled": true,
            "command": ["xcrun", "sourcekit-lsp"],
            "languageId": "swift",
            "scopes": ["source.swift"],
            "syntaxes": ["Packages/Swift/Syntaxes/Swift.tmLanguage"]
        }
    }
}

TAGML#

Follow installation instructions on LSP-tagml.

Terraform#

  1. Install the Terraform package from Package Control for syntax highlighting.
  2. Download terraform-lsp binary and make it available in your PATH.
  3. Open Preferences > Package Settings > LSP > Settings and add the "terraform" client configuration to the "clients":
{
    "clients": {
        "terraform": {
            "enabled": true,
            "command": ["terraform-lsp"],
            "selector": "source.terraform"
        }
    }
}
{
    "clients": {
        "terraform": {
            "enabled": true,
            "command": ["terraform-lsp"],
            "languageId": "terraform",
            "scopes": ["source.terraform"],
            "syntaxes":  ["Packages/Terraform/Terraform.sublime-syntax"]
        }
    }
}

TypeScript / JavaScript#

Follow installation instructions on LSP-typescript.

Vue#

Follow installation instructions on LSP-vue.

XML#

Follow installation instructions on LSP-lemminx.

YAML#

Follow installation instructions on LSP-yaml.