path: root/PACKAGES.md

<!--- THIS FILE IS GENERATED. DO NOT EDIT MANUALLY. -->
# Mason Package Index
> `:Mason`

- [actionlint](#actionlint)
- [ada-language-server](#ada-language-server)
- [alex](#alex)
- [angular-language-server](#angular-language-server)
- [ansible-language-server](#ansible-language-server)
- [ansible-lint](#ansible-lint)
- [antlers-language-server](#antlers-language-server)
- [apex-language-server](#apex-language-server)
- [arduino-language-server](#arduino-language-server)
- [asm-lsp](#asm-lsp)
- [astro-language-server](#astro-language-server)
- [autoflake](#autoflake)
- [autopep8](#autopep8)
- [awk-language-server](#awk-language-server)
- [azure-pipelines-language-server](#azure-pipelines-language-server)
- [bash-debug-adapter](#bash-debug-adapter)
- [bash-language-server](#bash-language-server)
- [beancount-language-server](#beancount-language-server)
- [beautysh](#beautysh)
- [bicep-lsp](#bicep-lsp)
- [black](#black)
- [blackd-client](#blackd-client)
- [blade-formatter](#blade-formatter)
- [blue](#blue)
- [brighterscript](#brighterscript)
- [brighterscript-formatter](#brighterscript-formatter)
- [bsl-language-server](#bsl-language-server)
- [bslint](#bslint)
- [buf](#buf)
- [buf-language-server](#buf-language-server)
- [buildifier](#buildifier)
- [bzl](#bzl)
- [cbfmt](#cbfmt)
- [cfn-lint](#cfn-lint)
- [chrome-debug-adapter](#chrome-debug-adapter)
- [clang-format](#clang-format)
- [clangd](#clangd)
- [clarinet](#clarinet)
- [clarity-lsp](#clarity-lsp)
- [clj-kondo](#clj-kondo)
- [clojure-lsp](#clojure-lsp)
- [cmake-language-server](#cmake-language-server)
- [cmakelang](#cmakelang)
- [cmakelint](#cmakelint)
- [codelldb](#codelldb)
- [codeql](#codeql)
- [codespell](#codespell)
- [colorgen-nvim](#colorgen-nvim)
- [commitlint](#commitlint)
- [cpplint](#cpplint)
- [cpptools](#cpptools)
- [cql-language-server](#cql-language-server)
- [crystalline](#crystalline)
- [csharp-language-server](#csharp-language-server)
- [csharpier](#csharpier)
- [cspell](#cspell)
- [css-lsp](#css-lsp)
- [cssmodules-language-server](#cssmodules-language-server)
- [cucumber-language-server](#cucumber-language-server)
- [cueimports](#cueimports)
- [cuelsp](#cuelsp)
- [curlylint](#curlylint)
- [dart-debug-adapter](#dart-debug-adapter)
- [debugpy](#debugpy)
- [delve](#delve)
- [deno](#deno)
- [dhall-lsp](#dhall-lsp)
- [diagnostic-languageserver](#diagnostic-languageserver)
- [djlint](#djlint)
- [docker-compose-language-service](#docker-compose-language-service)
- [dockerfile-language-server](#dockerfile-language-server)
- [dot-language-server](#dot-language-server)
- [dprint](#dprint)
- [drools-lsp](#drools-lsp)
- [editorconfig-checker](#editorconfig-checker)
- [efm](#efm)
- [elixir-ls](#elixir-ls)
- [elm-format](#elm-format)
- [elm-language-server](#elm-language-server)
- [ember-language-server](#ember-language-server)
- [emmet-ls](#emmet-ls)
- [erb-lint](#erb-lint)
- [erg](#erg)
- [erg-language-server](#erg-language-server)
- [erlang-ls](#erlang-ls)
- [esbonio](#esbonio)
- [eslint-lsp](#eslint-lsp)
- [eslint_d](#eslint_d)
- [fantomas](#fantomas)
- [fennel-language-server](#fennel-language-server)
- [firefox-debug-adapter](#firefox-debug-adapter)
- [fixjson](#fixjson)
- [flake8](#flake8)
- [flux-lsp](#flux-lsp)
- [foam-language-server](#foam-language-server)
- [fortls](#fortls)
- [fourmolu](#fourmolu)
- [fsautocomplete](#fsautocomplete)
- [gersemi](#gersemi)
- [gh](#gh)
- [gitlint](#gitlint)
- [gitui](#gitui)
- [gleam](#gleam)
- [glint](#glint)
- [glow](#glow)
- [go-debug-adapter](#go-debug-adapter)
- [gofumpt](#gofumpt)
- [goimports](#goimports)
- [goimports-reviser](#goimports-reviser)
- [golangci-lint](#golangci-lint)
- [golangci-lint-langserver](#golangci-lint-langserver)
- [golines](#golines)
- [gomodifytags](#gomodifytags)
- [google-java-format](#google-java-format)
- [gopls](#gopls)
- [gospel](#gospel)
- [gotests](#gotests)
- [gotestsum](#gotestsum)
- [gradle-language-server](#gradle-language-server)
- [grammarly-languageserver](#grammarly-languageserver)
- [graphql-language-service-cli](#graphql-language-service-cli)
- [groovy-language-server](#groovy-language-server)
- [hadolint](#hadolint)
- [haml-lint](#haml-lint)
- [haskell-language-server](#haskell-language-server)
- [haxe-language-server](#haxe-language-server)
- [helm-ls](#helm-ls)
- [hoon-language-server](#hoon-language-server)
- [html-lsp](#html-lsp)
- [iferr](#iferr)
- [impl](#impl)
- [intelephense](#intelephense)
- [isort](#isort)
- [java-debug-adapter](#java-debug-adapter)
- [java-language-server](#java-language-server)
- [java-test](#java-test)
- [jdtls](#jdtls)
- [jedi-language-server](#jedi-language-server)
- [joker](#joker)
- [jq](#jq)
- [jq-lsp](#jq-lsp)
- [js-debug-adapter](#js-debug-adapter)
- [json-lsp](#json-lsp)
- [json-to-struct](#json-to-struct)
- [jsonlint](#jsonlint)
- [jsonnet-language-server](#jsonnet-language-server)
- [julia-lsp](#julia-lsp)
- [kotlin-debug-adapter](#kotlin-debug-adapter)
- [kotlin-language-server](#kotlin-language-server)
- [ktlint](#ktlint)
- [latexindent](#latexindent)
- [lelwel](#lelwel)
- [lemminx](#lemminx)
- [lemmy-help](#lemmy-help)
- [ltex-ls](#ltex-ls)
- [lua-language-server](#lua-language-server)
- [luacheck](#luacheck)
- [luaformatter](#luaformatter)
- [luau-lsp](#luau-lsp)
- [markdown-toc](#markdown-toc)
- [markdownlint](#markdownlint)
- [marksman](#marksman)
- [metamath-zero-lsp](#metamath-zero-lsp)
- [millet](#millet)
- [misspell](#misspell)
- [mockdebug](#mockdebug)
- [move-analyzer](#move-analyzer)
- [mypy](#mypy)
- [neocmakelsp](#neocmakelsp)
- [netcoredbg](#netcoredbg)
- [nginx-language-server](#nginx-language-server)
- [nickel-lang-lsp](#nickel-lang-lsp)
- [nil](#nil)
- [nimlsp](#nimlsp)
- [node-debug2-adapter](#node-debug2-adapter)
- [nxls](#nxls)
- [ocaml-lsp](#ocaml-lsp)
- [ocamlformat](#ocamlformat)
- [ols](#ols)
- [omnisharp](#omnisharp)
- [omnisharp-mono](#omnisharp-mono)
- [opencl-language-server](#opencl-language-server)
- [openedge-language-server](#openedge-language-server)
- [openscad-lsp](#openscad-lsp)
- [perlnavigator](#perlnavigator)
- [php-cs-fixer](#php-cs-fixer)
- [php-debug-adapter](#php-debug-adapter)
- [phpactor](#phpactor)
- [phpcbf](#phpcbf)
- [phpcs](#phpcs)
- [phpmd](#phpmd)
- [phpstan](#phpstan)
- [pint](#pint)
- [powershell-editor-services](#powershell-editor-services)
- [prettier](#prettier)
- [prettierd](#prettierd)
- [prisma-language-server](#prisma-language-server)
- [proselint](#proselint)
- [prosemd-lsp](#prosemd-lsp)
- [protolint](#protolint)
- [psalm](#psalm)
- [puppet-editor-services](#puppet-editor-services)
- [purescript-language-server](#purescript-language-server)
- [pydocstyle](#pydocstyle)
- [pyflakes](#pyflakes)
- [pylama](#pylama)
- [pylint](#pylint)
- [pylyzer](#pylyzer)
- [pyproject-flake8](#pyproject-flake8)
- [pyre](#pyre)
- [pyright](#pyright)
- [python-lsp-server](#python-lsp-server)
- [quick-lint-js](#quick-lint-js)
- [r-languageserver](#r-languageserver)
- [raku-navigator](#raku-navigator)
- [reason-language-server](#reason-language-server)
- [remark-cli](#remark-cli)
- [remark-language-server](#remark-language-server)
- [reorder-python-imports](#reorder-python-imports)
- [rescript-lsp](#rescript-lsp)
- [revive](#revive)
- [rnix-lsp](#rnix-lsp)
- [robotframework-lsp](#robotframework-lsp)
- [rome](#rome)
- [rstcheck](#rstcheck)
- [rubocop](#rubocop)
- [ruby-lsp](#ruby-lsp)
- [ruff](#ruff)
- [ruff-lsp](#ruff-lsp)
- [rust-analyzer](#rust-analyzer)
- [rustfmt](#rustfmt)
- [rustywind](#rustywind)
- [salt-lsp](#salt-lsp)
- [selene](#selene)
- [semgrep](#semgrep)
- [serve-d](#serve-d)
- [shellcheck](#shellcheck)
- [shellharden](#shellharden)
- [shfmt](#shfmt)
- [shopify-theme-check](#shopify-theme-check)
- [slint-lsp](#slint-lsp)
- [smithy-language-server](#smithy-language-server)
- [snakefmt](#snakefmt)
- [solang](#solang)
- [solang-llvm](#solang-llvm)
- [solargraph](#solargraph)
- [solhint](#solhint)
- [solidity](#solidity)
- [solidity-ls](#solidity-ls)
- [sorbet](#sorbet)
- [sourcery](#sourcery)
- [spectral-language-server](#spectral-language-server)
- [sql-formatter](#sql-formatter)
- [sqlfluff](#sqlfluff)
- [sqlfmt](#sqlfmt)
- [sqlls](#sqlls)
- [sqls](#sqls)
- [standardrb](#standardrb)
- [staticcheck](#staticcheck)
- [stylelint](#stylelint)
- [stylelint-lsp](#stylelint-lsp)
- [stylua](#stylua)
- [svelte-language-server](#svelte-language-server)
- [svlangserver](#svlangserver)
- [svls](#svls)
- [tailwindcss-language-server](#tailwindcss-language-server)
- [taplo](#taplo)
- [teal-language-server](#teal-language-server)
- [tectonic](#tectonic)
- [terraform-ls](#terraform-ls)
- [texlab](#texlab)
- [textlint](#textlint)
- [tflint](#tflint)
- [tree-sitter-cli](#tree-sitter-cli)
- [twigcs](#twigcs)
- [typescript-language-server](#typescript-language-server)
- [typst-lsp](#typst-lsp)
- [unocss-language-server](#unocss-language-server)
- [usort](#usort)
- [vacuum](#vacuum)
- [vala-language-server](#vala-language-server)
- [vale](#vale)
- [verible](#verible)
- [veryl-ls](#veryl-ls)
- [vetur-vls](#vetur-vls)
- [vim-language-server](#vim-language-server)
- [vint](#vint)
- [visualforce-language-server](#visualforce-language-server)
- [vls](#vls)
- [vtsls](#vtsls)
- [vue-language-server](#vue-language-server)
- [vulture](#vulture)
- [wgsl-analyzer](#wgsl-analyzer)
- [write-good](#write-good)
- [xmlformatter](#xmlformatter)
- [xo](#xo)
- [yaml-language-server](#yaml-language-server)
- [yamlfmt](#yamlfmt)
- [yamllint](#yamllint)
- [yapf](#yapf)
- [yls-yara](#yls-yara)
- [zk](#zk)
- [zls](#zls)

# actionlint

> Static checker for GitHub Actions workflow files.

Homepage: [https://github.com/rhysd/actionlint](https://github.com/rhysd/actionlint)  
Languages: `YAML`  
Categories: `Linter`  

```
:MasonInstall actionlint
```
# ada-language-server

> Ada/SPARK language server.

Homepage: [https://github.com/AdaCore/ada_language_server](https://github.com/AdaCore/ada_language_server)  
Languages: `Ada`  
Categories: `LSP`  

```
:MasonInstall ada-language-server
```
# alex

> Catch insensitive, inconsiderate writing.

Homepage: [https://github.com/get-alex/alex](https://github.com/get-alex/alex)  
Languages: `Markdown`  
Categories: `Linter`  

```
:MasonInstall alex
```
# angular-language-server

> The Angular Language Service provides code editors with a way to get completions, errors, hints, and navigation inside
Angular templates. It works with external templates in separate HTML files, and also with in-line templates.


Homepage: [https://angular.io/guide/language-service](https://angular.io/guide/language-service)  
Languages: `Angular`  
Categories: `LSP`  

```
:MasonInstall angular-language-server
```
# ansible-language-server

> Ansible Language Server.

Homepage: [https://github.com/ansible/ansible-language-server](https://github.com/ansible/ansible-language-server)  
Languages: `Ansible`  
Categories: `LSP`  

```
:MasonInstall ansible-language-server
```
# ansible-lint

> Ansible Lint is a command-line tool for linting playbooks, roles and collections aimed toward any Ansible users.

Homepage: [https://github.com/ansible/ansible-lint](https://github.com/ansible/ansible-lint)  
Languages: `Ansible`  
Categories: `Linter`  

```
:MasonInstall ansible-lint
```
# antlers-language-server

> Provides rich language features for Statamic's Antlers templating language, including code completions, syntax
highlighting, and more.


Homepage: [https://github.com/Stillat/vscode-antlers-language-server](https://github.com/Stillat/vscode-antlers-language-server)  
Languages: `Antlers`  
Categories: `LSP`  

```
:MasonInstall antlers-language-server
```
# apex-language-server

> The Apex Language Server is an IDE-agnostic way for tools to access code-editing capabilities such as code completion, go to definition, find all usage, and refactoring.

Homepage: [https://github.com/forcedotcom/salesforcedx-vscode](https://github.com/forcedotcom/salesforcedx-vscode)  
Languages: `Apex`  
Categories: `LSP`  

```
:MasonInstall apex-language-server
```
# arduino-language-server

> An Arduino Language Server based on Clangd to Arduino code autocompletion.

Homepage: [https://github.com/arduino/arduino-language-server](https://github.com/arduino/arduino-language-server)  
Languages: `Arduino`  
Categories: `LSP`  

```
:MasonInstall arduino-language-server
```
# asm-lsp

> Language server for NASM/GAS/GO Assembly.

Homepage: [https://github.com/bergercookie/asm-lsp](https://github.com/bergercookie/asm-lsp)  
Languages: `Assembly`  
Categories: `LSP`  

```
:MasonInstall asm-lsp
```
# astro-language-server

> The Astro language server, its structure is inspired by the Svelte Language Server.

Homepage: [https://github.com/withastro/language-tools](https://github.com/withastro/language-tools)  
Languages: `Astro`  
Categories: `LSP`  

```
:MasonInstall astro-language-server
```
# autoflake

> autoflake removes unused imports and unused variables from Python code.

Homepage: [https://pypi.org/project/autoflake/](https://pypi.org/project/autoflake/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall autoflake
```
# autopep8

> A tool that automatically formats Python code to conform to the PEP 8 style guide.

Homepage: [https://pypi.org/project/autopep8/](https://pypi.org/project/autopep8/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall autopep8
```
# awk-language-server

> Language Server for AWK.

Homepage: [https://github.com/Beaglefoot/awk-language-server](https://github.com/Beaglefoot/awk-language-server)  
Languages: `AWK`  
Categories: `LSP`  

```
:MasonInstall awk-language-server
```
# azure-pipelines-language-server

> A language server for Azure Pipelines YAML.

Homepage: [https://github.com/microsoft/azure-pipelines-language-server](https://github.com/microsoft/azure-pipelines-language-server)  
Languages: `Azure Pipelines`  
Categories: `LSP`  

```
:MasonInstall azure-pipelines-language-server
```
# bash-debug-adapter

> Bash shell debugger, based on bashdb.

Homepage: [https://github.com/rogalmic/vscode-bash-debug](https://github.com/rogalmic/vscode-bash-debug)  
Languages: `Bash`  
Categories: `DAP`  

```
:MasonInstall bash-debug-adapter
```
# bash-language-server

> A language server for Bash.

Homepage: [https://github.com/bash-lsp/bash-language-server](https://github.com/bash-lsp/bash-language-server)  
Languages: `Bash`  
Categories: `LSP`  

```
:MasonInstall bash-language-server
```
# beancount-language-server

> A Language Server Protocol (LSP) for beancount files.

Homepage: [https://github.com/polarmutex/beancount-language-server](https://github.com/polarmutex/beancount-language-server)  
Languages: `Beancount`  
Categories: `LSP`  

```
:MasonInstall beancount-language-server
```
# beautysh

> beautysh - A Bash beautifier for the masses.

Homepage: [https://github.com/lovesegfault/beautysh](https://github.com/lovesegfault/beautysh)  
Languages: `Bash` `Csh` `Ksh` `Sh` `Zsh`  
Categories: `Formatter`  

```
:MasonInstall beautysh
```
# bicep-lsp

> Bicep is a declarative language for describing and deploying Azure resources

Homepage: [https://github.com/Azure/bicep](https://github.com/Azure/bicep)  
Languages: `Bicep`  
Categories: `LSP`  

```
:MasonInstall bicep-lsp
```
# black

> Black, the uncompromising Python code formatter.

Homepage: [https://pypi.org/project/black/](https://pypi.org/project/black/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall black
```
# blackd-client

> Tiny HTTP client for the Black (blackd) Python code formatter.

Homepage: [https://github.com/disrupted/blackd-client](https://github.com/disrupted/blackd-client)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall blackd-client
```
# blade-formatter

> An opinionated blade template formatter for Laravel that respects readability.

Homepage: [https://github.com/shufo/blade-formatter](https://github.com/shufo/blade-formatter)  
Languages: `Blade`  
Categories: `Formatter`  

```
:MasonInstall blade-formatter
```
# blue

> blue is a somewhat less uncompromising code formatter than black, the OG of Python formatters. We love the idea of
automatically formatting Python code, for the same reasons that inspired black, however we take issue with some of the
decisions black makes. Kudos to black for pioneering code formatting for Python, and for its excellent implementation.


Homepage: [https://blue.readthedocs.io/en/latest/](https://blue.readthedocs.io/en/latest/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall blue
```
# brighterscript

> A superset of Roku's BrightScript language.

Homepage: [https://github.com/RokuCommunity/brighterscript](https://github.com/RokuCommunity/brighterscript)  
Languages: `BrighterScript`  
Categories: `Compiler` `LSP`  

```
:MasonInstall brighterscript
```
# brighterscript-formatter

> A code formatter for BrightScript and BrighterScript.

Homepage: [https://github.com/rokucommunity/brighterscript-formatter](https://github.com/rokucommunity/brighterscript-formatter)  
Languages: `BrighterScript`  
Categories: `Formatter`  

```
:MasonInstall brighterscript-formatter
```
# bsl-language-server

> Implementation of Language Server Protocol for Language 1C (BSL).

Homepage: [https://1c-syntax.github.io/bsl-language-server](https://1c-syntax.github.io/bsl-language-server)  
Languages: `1С:Enterprise` `OneScript`  
Categories: `LSP`  

```
:MasonInstall bsl-language-server
```
# bslint

> A BrighterScript CLI tool to lint your code without compiling your project.

Homepage: [https://github.com/rokucommunity/bslint](https://github.com/rokucommunity/bslint)  
Languages: `BrighterScript`  
Categories: `Linter`  

```
:MasonInstall bslint
```
# buf

> The Buf CLI is a one stop shop for your local Protocol Buffers needs. It comes with a linter that enforces good API
designs, a breaking change detector, a generator, a formatter that formats your Protobuf files in accordance with
industry standards. It also helps you manage your Protobuf assets on the Buf Schema Registry.


Homepage: [https://buf.build](https://buf.build)  
Languages: `Protobuf`  
Categories: `Linter` `Formatter`  

```
:MasonInstall buf
```
# buf-language-server

> buf-language-server is a prototype for the beginnings of a Protobuf language server compatible with Buf modules and workspaces.


Homepage: [https://github.com/bufbuild/buf-language-server](https://github.com/bufbuild/buf-language-server)  
Languages: `Protobuf`  
Categories: `LSP`  

```
:MasonInstall buf-language-server
```
# buildifier

> buildifier is a tool for formatting and linting bazel BUILD, WORKSPACE, and .bzl files.

Homepage: [https://github.com/bazelbuild/buildtools](https://github.com/bazelbuild/buildtools)  
Languages: `Bazel`  
Categories: `Linter` `Formatter`  

```
:MasonInstall buildifier
```
# bzl

> Autocompletion, hover documentation, and debugging for BUILD files. Get a huge productivity boost with rule,
attribute, and function definitions right in your IDE.


Homepage: [https://bzl.io/](https://bzl.io/)  
Languages: `Starlark`  
Categories: `LSP` `DAP`  

```
:MasonInstall bzl
```
# cbfmt

> A tool to format codeblocks inside markdown and org documents. It iterates over all codeblocks, and formats them with
the tool(s) specified for the language of the block.


Homepage: [https://github.com/lukas-reineke/cbfmt](https://github.com/lukas-reineke/cbfmt)  
Languages: `Markdown`  
Categories: `Formatter`  

```
:MasonInstall cbfmt
```
# cfn-lint

> CloudFormation Linter. Validate AWS CloudFormation YAML/JSON templates against the AWS CloudFormation Resource
Specification and additional checks. Includes checking valid values for resource properties and best practices.


Homepage: [https://github.com/aws-cloudformation/cfn-lint](https://github.com/aws-cloudformation/cfn-lint)  
Languages: `YAML` `JSON`  
Categories: `Linter`  

```
:MasonInstall cfn-lint
```
# chrome-debug-adapter

> Debug your JavaScript code running in Google Chrome.

Homepage: [https://github.com/Microsoft/vscode-chrome-debug](https://github.com/Microsoft/vscode-chrome-debug)  
Languages: `JavaScript` `TypeScript`  
Categories: `DAP`  

```
:MasonInstall chrome-debug-adapter
```
# clang-format

> clang-format is formatter for C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code.

Homepage: [https://pypi.org/project/clang-format/](https://pypi.org/project/clang-format/)  
Languages: `C` `C#` `C++` `JSON` `Java` `JavaScript`  
Categories: `Formatter`  

```
:MasonInstall clang-format
```
# clangd

> clangd understands your C++ code and adds smart features to your editor: code completion, compile errors,
go-to-definition and more.


Homepage: [https://clangd.llvm.org](https://clangd.llvm.org)  
Languages: `C` `C++`  
Categories: `LSP`  

```
:MasonInstall clangd
```
# clarinet

> Clarinet is a simple, modern and opinionated runtime for testing, integrating and deploying Clarity smart contracts.


Homepage: [https://github.com/hirosystems/clarinet](https://github.com/hirosystems/clarinet)  
Languages: `Clarity`  
Categories: `LSP` `Runtime`  

```
:MasonInstall clarinet
```
# clarity-lsp

> Language Server Protocol implementation for Clarity.

Homepage: [https://github.com/hirosystems/clarity-lsp](https://github.com/hirosystems/clarity-lsp)  
Languages: `Clarity`  
Categories: `LSP`  

```
:MasonInstall clarity-lsp
```
# clj-kondo

> Clj-kondo performs static analysis on Clojure, ClojureScript and EDN, without the need of a running REPL. It informs
you about potential errors while you are typing.


Homepage: [https://github.com/clj-kondo/clj-kondo](https://github.com/clj-kondo/clj-kondo)  
Languages: `Clojure` `ClojureScript`  
Categories: `Linter`  

```
:MasonInstall clj-kondo
```
# clojure-lsp

> A Language Server for Clojure(script). Taking a Cursive-like approach of statically analyzing code.

Homepage: [https://clojure-lsp.io](https://clojure-lsp.io)  
Languages: `Clojure` `ClojureScript`  
Categories: `LSP`  

```
:MasonInstall clojure-lsp
```
# cmake-language-server

> CMake LSP Implementation.

Homepage: [https://github.com/regen100/cmake-language-server](https://github.com/regen100/cmake-language-server)  
Languages: `CMake`  
Categories: `LSP`  

```
:MasonInstall cmake-language-server
```
# cmakelang

> Language tools for cmake (format, lint, etc).

Homepage: [https://pypi.org/project/cmakelang/](https://pypi.org/project/cmakelang/)  
Languages: `CMake`  
Categories: `Formatter` `Linter`  

```
:MasonInstall cmakelang
```
# cmakelint

> cmakelint parses CMake files and reports style issues.

Homepage: [https://github.com/cmake-lint/cmake-lint](https://github.com/cmake-lint/cmake-lint)  
Languages: `CMake`  
Categories: `Linter`  

```
:MasonInstall cmakelint
```
# codelldb

> A native debugger based on LLDB.

Homepage: [https://github.com/vadimcn/vscode-lldb](https://github.com/vadimcn/vscode-lldb)  
Languages: `C` `C++` `Rust`  
Categories: `DAP`  

```
:MasonInstall codelldb
```
# codeql

> Discover vulnerabilities across a codebase with CodeQL, our industry-leading semantic code analysis engine. CodeQL
lets you query code as though it were data. Write a query to find all variants of a vulnerability, eradicating it
forever. Then share your query to help others do the same.


Homepage: [https://github.com/github/codeql-cli-binaries](https://github.com/github/codeql-cli-binaries)  
Languages: `CodeQL`  
Categories: `LSP`  

```
:MasonInstall codeql
```
# codespell

> Check code for common misspellings.

Homepage: [https://github.com/codespell-project/codespell](https://github.com/codespell-project/codespell)  
Languages:   
Categories: `Linter`  

```
:MasonInstall codespell
```
# colorgen-nvim

> Blazingly fast colorscheme generator for Neovim written in Rust.

Homepage: [https://github.com/ChristianChiarulli/colorgen-nvim](https://github.com/ChristianChiarulli/colorgen-nvim)  
Languages:   
Categories: `Compiler`  

```
:MasonInstall colorgen-nvim
```
# commitlint

> commitlint checks if your commit messages meet the conventional commit format.

Homepage: [https://commitlint.js.org/](https://commitlint.js.org/)  
Languages:   
Categories: `Linter`  

```
:MasonInstall commitlint
```
# cpplint

> Cpplint is a command-line tool to check C/C++ files for style issues following Google's C++ style guide.

Homepage: [https://pypi.org/project/cpplint/](https://pypi.org/project/cpplint/)  
Languages: `C` `C++`  
Categories: `Linter`  

```
:MasonInstall cpplint
```
# cpptools

> Official repository for the Microsoft C/C++ extension for VS Code.

Homepage: [https://github.com/microsoft/vscode-cpptools](https://github.com/microsoft/vscode-cpptools)  
Languages: `C` `C++` `Rust`  
Categories: `DAP`  

```
:MasonInstall cpptools
```
# cql-language-server

> A language server for Clinical Quality Language (CQL).

Homepage: [https://github.com/cqframework/cql-language-server](https://github.com/cqframework/cql-language-server)  
Languages: `CQL`  
Categories: `LSP`  

```
:MasonInstall cql-language-server
```
# crystalline

> A Language Server Protocol implementation for Crystal.

Homepage: [https://github.com/elbywan/crystalline](https://github.com/elbywan/crystalline)  
Languages: `Crystal`  
Categories: `LSP`  

```
:MasonInstall crystalline
```
# csharp-language-server

> Roslyn-based LSP language server for C#.

Homepage: [https://github.com/razzmatazz/csharp-language-server](https://github.com/razzmatazz/csharp-language-server)  
Languages: `C#`  
Categories: `LSP`  

```
:MasonInstall csharp-language-server
```
# csharpier

> CSharpier is an opinionated code formatter for C#.

Homepage: [https://csharpier.com](https://csharpier.com)  
Languages: `C#`  
Categories: `Formatter`  

```
:MasonInstall csharpier
```
# cspell

> A Spell Checker for Code.

Homepage: [https://github.com/streetsidesoftware/cspell](https://github.com/streetsidesoftware/cspell)  
Languages:   
Categories: `Linter`  

```
:MasonInstall cspell
```
# css-lsp

> Language Server Protocol implementation for CSS, SCSS & LESS.

Homepage: [https://github.com/microsoft/vscode-css-languageservice](https://github.com/microsoft/vscode-css-languageservice)  
Languages: `CSS` `SCSS` `LESS`  
Categories: `LSP`  

```
:MasonInstall css-lsp
```
# cssmodules-language-server

> Autocompletion and go-to-definition for cssmodules.

Homepage: [https://github.com/antonk52/cssmodules-language-server](https://github.com/antonk52/cssmodules-language-server)  
Languages: `CSS`  
Categories: `LSP`  

```
:MasonInstall cssmodules-language-server
```
# cucumber-language-server

> Cucumber Language Server.

Homepage: [https://github.com/cucumber/language-server](https://github.com/cucumber/language-server)  
Languages: `Cucumber`  
Categories: `LSP`  

```
:MasonInstall cucumber-language-server
```
# cueimports

> CUE tool that updates your import lines, adding missing ones and removing unused ones.

Homepage: [https://github.com/asdine/cueimports](https://github.com/asdine/cueimports)  
Languages: `Cue`  
Categories: `Formatter`  

```
:MasonInstall cueimports
```
# cuelsp

> Language Server implementation for CUE, with built-in support for Dagger.

Homepage: [https://github.com/dagger/cuelsp](https://github.com/dagger/cuelsp)  
Languages: `Cue`  
Categories: `LSP`  

```
:MasonInstall cuelsp
```
# curlylint

> Experimental HTML templates linting for Jinja, Nunjucks, Django templates, Twig, Liquid.

Homepage: [https://www.curlylint.org/](https://www.curlylint.org/)  
Languages: `Django` `Jinja` `Liquid` `Nunjucks` `Twig`  
Categories: `Linter`  

```
:MasonInstall curlylint
```
# dart-debug-adapter

> Dart debug adapter sourced from the Dart VSCode extension.

Homepage: [https://github.com/Dart-Code/Dart-Code](https://github.com/Dart-Code/Dart-Code)  
Languages: `Dart`  
Categories: `DAP`  

```
:MasonInstall dart-debug-adapter
```
# debugpy

> An implementation of the Debug Adapter Protocol for Python.

Homepage: [https://github.com/microsoft/debugpy](https://github.com/microsoft/debugpy)  
Languages: `Python`  
Categories: `DAP`  

```
:MasonInstall debugpy
```
# delve

> Delve is a debugger for the Go programming language.

Homepage: [https://github.com/go-delve/delve](https://github.com/go-delve/delve)  
Languages: `Go`  
Categories: `DAP`  

```
:MasonInstall delve
```
# deno

> Deno (/ˈdiːnoʊ/, pronounced dee-no) is a JavaScript, TypeScript, and WebAssembly runtime with secure defaults and a
great developer experience.


Homepage: [https://deno.land/](https://deno.land/)  
Languages: `JavaScript` `TypeScript`  
Categories: `LSP` `Runtime`  

```
:MasonInstall deno
```
# dhall-lsp

> LSP server implementation for Dhall.

Homepage: [https://github.com/dhall-lang/dhall-haskell/tree/master/dhall-lsp-server](https://github.com/dhall-lang/dhall-haskell/tree/master/dhall-lsp-server)  
Languages: `Dhall`  
Categories: `LSP`  

```
:MasonInstall dhall-lsp
```
# diagnostic-languageserver

> Diagnostic language server that integrates with linters.

Homepage: [https://github.com/iamcco/diagnostic-languageserver](https://github.com/iamcco/diagnostic-languageserver)  
Languages:   
Categories: `LSP`  

```
:MasonInstall diagnostic-languageserver
```
# djlint

> HTML Template Linter and Formatter. Django - Jinja - Nunjucks - Handlebars - GoLang.

Homepage: [https://github.com/Riverside-Healthcare/djLint](https://github.com/Riverside-Healthcare/djLint)  
Languages: `Django` `Go` `Nunjucks` `Handlebargs` `Mustache` `Angular` `Jinja`  
Categories: `Formatter` `Linter`  

```
:MasonInstall djlint
```
# docker-compose-language-service

> A language server for Docker Compose.

Homepage: [https://github.com/microsoft/compose-language-service](https://github.com/microsoft/compose-language-service)  
Languages: `Docker`  
Categories: `LSP`  

```
:MasonInstall docker-compose-language-service
```
# dockerfile-language-server

> A language server for Dockerfiles powered by Node.js, TypeScript, and VSCode technologies.

Homepage: [https://github.com/rcjsuen/dockerfile-language-server-nodejs](https://github.com/rcjsuen/dockerfile-language-server-nodejs)  
Languages: `Docker`  
Categories: `LSP`  

```
:MasonInstall dockerfile-language-server
```
# dot-language-server

> A language server for the DOT language.

Homepage: [https://github.com/nikeee/dot-language-server](https://github.com/nikeee/dot-language-server)  
Languages: `DOT`  
Categories: `LSP`  

```
:MasonInstall dot-language-server
```
# dprint

> A pluggable and configurable code formatting platform written in Rust.

Homepage: [https://dprint.dev/](https://dprint.dev/)  
Languages:   
Categories: `Formatter`  

```
:MasonInstall dprint
```
# drools-lsp

> An implementation of a language server for the Drools Rule Language.

Homepage: [https://github.com/kiegroup/drools-lsp](https://github.com/kiegroup/drools-lsp)  
Languages: `Drools`  
Categories: `LSP`  

```
:MasonInstall drools-lsp
```
# editorconfig-checker

> A tool to verify that your files are in harmony with your `.editorconfig`.

Homepage: [https://github.com/editorconfig-checker/editorconfig-checker](https://github.com/editorconfig-checker/editorconfig-checker)  
Languages:   
Categories: `Linter`  

```
:MasonInstall editorconfig-checker
```
# efm

> General purpose Language Server.

Homepage: [https://github.com/mattn/efm-langserver](https://github.com/mattn/efm-langserver)  
Languages:   
Categories: `LSP`  

```
:MasonInstall efm
```
# elixir-ls

> A frontend-independent IDE "smartness" server for Elixir. Implements the "Language Server Protocol" standard and
provides debugger support via the "Debug Adapter Protocol".


Homepage: [https://github.com/elixir-lsp/elixir-ls](https://github.com/elixir-lsp/elixir-ls)  
Languages: `Elixir`  
Categories: `LSP` `DAP`  

```
:MasonInstall elixir-ls
```
# elm-format

> elm-format formats Elm source code according to a standard set of rules based on the official Elm Style Guide


Homepage: [https://github.com/avh4/elm-format](https://github.com/avh4/elm-format)  
Languages: `Elm`  
Categories: `Formatter`  

```
:MasonInstall elm-format
```
# elm-language-server

> Language server implementation for Elm.

Homepage: [https://github.com/elm-tooling/elm-language-server](https://github.com/elm-tooling/elm-language-server)  
Languages: `Elm`  
Categories: `LSP`  

```
:MasonInstall elm-language-server
```
# ember-language-server

> Language Server Protocol implementation for Ember.js and Glimmer projects.

Homepage: [https://github.com/lifeart/ember-language-server](https://github.com/lifeart/ember-language-server)  
Languages: `Ember`  
Categories: `LSP`  

```
:MasonInstall ember-language-server
```
# emmet-ls

> Emmet support based on LSP.

Homepage: [https://github.com/aca/emmet-ls](https://github.com/aca/emmet-ls)  
Languages: `Emmet`  
Categories: `LSP`  

```
:MasonInstall emmet-ls
```
# erb-lint

> erb-lint is a tool to help lint your ERB or HTML files using the included linters or by writing your own.

Homepage: [https://github.com/Shopify/erb-lint](https://github.com/Shopify/erb-lint)  
Languages: `HTML` `Ruby`  
Categories: `Linter`  

```
:MasonInstall erb-lint
```
# erg

> A statically typed language that can deeply improve the Python ecosystem.

Homepage: [https://github.com/erg-lang/erg](https://github.com/erg-lang/erg)  
Languages: `Erg`  
Categories: `Compiler` `LSP`  

```
:MasonInstall erg
```
# erg-language-server

> ELS is a language server for the Erg programing language.

Homepage: [https://github.com/erg-lang/erg-language-server](https://github.com/erg-lang/erg-language-server)  
Languages: `Erg`  
Categories: `LSP`  

```
:MasonInstall erg-language-server
```
# erlang-ls

> Erlang LS is a language server providing language features for the Erlang programming language. The server works with
Emacs, VSCode, Sublime Text 3, Vim and probably many more text editors and IDE which adhere to the LSP protocol.


Homepage: [https://erlang-ls.github.io/](https://erlang-ls.github.io/)  
Languages: `Erlang`  
Categories: `DAP` `LSP`  

```
:MasonInstall erlang-ls
```
# esbonio

> A Language Server for Sphinx projects.

Homepage: [https://pypi.org/project/esbonio/](https://pypi.org/project/esbonio/)  
Languages: `Sphinx`  
Categories: `LSP`  

```
:MasonInstall esbonio
```
# eslint-lsp

> Language Server Protocol implementation for ESLint. The server uses the ESLint library installed in the opened
workspace folder. If the folder doesn't provide one the extension looks for a global install version.


Homepage: [https://github.com/Microsoft/vscode-eslint](https://github.com/Microsoft/vscode-eslint)  
Languages: `JavaScript` `TypeScript`  
Categories: `LSP`  

```
:MasonInstall eslint-lsp
```
# eslint_d

> Makes eslint the fastest linter on the planet.

Homepage: [https://github.com/mantoni/eslint_d.js/](https://github.com/mantoni/eslint_d.js/)  
Languages: `TypeScript` `JavaScript`  
Categories: `Linter`  

```
:MasonInstall eslint_d
```
# fantomas

> Fantomas is an opinionated code formatter for F#.

Homepage: [https://fsprojects.github.io/fantomas](https://fsprojects.github.io/fantomas)  
Languages: `F#`  
Categories: `Formatter`  

```
:MasonInstall fantomas
```
# fennel-language-server

> Fennel language server protocol (LSP) support.

Homepage: [https://github.com/rydesun/fennel-language-server](https://github.com/rydesun/fennel-language-server)  
Languages: `Fennel`  
Categories: `LSP`  

```
:MasonInstall fennel-language-server
```
# firefox-debug-adapter

> Debug your web application or browser extension in Firefox.

Homepage: [https://github.com/firefox-devtools/vscode-firefox-debug](https://github.com/firefox-devtools/vscode-firefox-debug)  
Languages: `JavaScript` `TypeScript`  
Categories: `DAP`  

```
:MasonInstall firefox-debug-adapter
```
# fixjson

> A JSON file fixer/formatter for humans using (relaxed) JSON5.

Homepage: [https://github.com/rhysd/fixjson](https://github.com/rhysd/fixjson)  
Languages: `JSON`  
Categories: `Formatter`  

```
:MasonInstall fixjson
```
# flake8

> flake8 is a python tool that glues together pycodestyle, pyflakes, mccabe, and third-party plugins to check the style
and quality of some Python code.


Homepage: [https://github.com/PyCQA/flake8](https://github.com/PyCQA/flake8)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall flake8
```
# flux-lsp

> Implementation of Language Server Protocol for the Flux language.

Homepage: [https://github.com/influxdata/flux-lsp](https://github.com/influxdata/flux-lsp)  
Languages: `Flux`  
Categories: `LSP`  

```
:MasonInstall flux-lsp
```
# foam-language-server

> A language server for OpenFOAM case files.

Homepage: [https://github.com/FoamScience/foam-language-server](https://github.com/FoamScience/foam-language-server)  
Languages: `OpenFOAM`  
Categories: `LSP`  

```
:MasonInstall foam-language-server
```
# fortls

> fortls - Fortran Language Server.

Homepage: [https://github.com/gnikit/fortls](https://github.com/gnikit/fortls)  
Languages: `Fortran`  
Categories: `LSP`  

```
:MasonInstall fortls
```
# fourmolu

> A fork of Ormolu that uses four space indentation and allows arbitrary configuration.

Homepage: [https://hackage.haskell.org/package/fourmolu](https://hackage.haskell.org/package/fourmolu)  
Languages: `Haskell`  
Categories: `Formatter`  

```
:MasonInstall fourmolu
```
# fsautocomplete

> F# language server using Language Server Protocol.

Homepage: [https://github.com/fsharp/FsAutoComplete](https://github.com/fsharp/FsAutoComplete)  
Languages: `F#`  
Categories: `LSP`  

```
:MasonInstall fsautocomplete
```
# gersemi

> gersemi - A formatter to make your CMake code the real treasure.

Homepage: [https://github.com/BlankSpruce/gersemi](https://github.com/BlankSpruce/gersemi)  
Languages: `CMake`  
Categories: `Formatter`  

```
:MasonInstall gersemi
```
# gh

> gh is GitHub on the command line. It brings pull requests, issues, and other GitHub concepts to the terminal next to
where you are already working with git and your code.


Homepage: [https://cli.github.com](https://cli.github.com)  
Languages:   
Categories:   

```
:MasonInstall gh
```
# gitlint

> Gitlint is a git commit message linter written in Python: it checks your commit messages for style.

Homepage: [https://jorisroovers.com/gitlint/](https://jorisroovers.com/gitlint/)  
Languages:   
Categories: `Linter`  

```
:MasonInstall gitlint
```
# gitui

> Blazing fast terminal-ui for git written in Rust.

Homepage: [https://github.com/extrawurst/gitui](https://github.com/extrawurst/gitui)  
Languages:   
Categories:   

```
:MasonInstall gitui
```
# gleam

> A friendly language for building type-safe, scalable systems!

Homepage: [https://gleam.run/](https://gleam.run/)  
Languages: `Gleam`  
Categories: `Compiler` `Formatter` `LSP`  

```
:MasonInstall gleam
```
# glint

> Glint is a set of tools to aid in developing code that uses the Glimmer VM for rendering, such as Ember.js v3.24+ and
GlimmerX projects. Similar to Vetur for Vue projects or Svelte Language Tools, Glint consists of a CLI and a language
server to provide feedback and enforce correctness both locally during editing and project-wide in CI.


Homepage: [https://typed-ember.gitbook.io/glint/](https://typed-ember.gitbook.io/glint/)  
Languages: `Handlebars` `Glimmer` `TypeScript` `JavaScript`  
Categories: `LSP` `Linter`  

```
:MasonInstall glint
```
# glow

> Render markdown on the CLI, with pizzazz!

Homepage: [https://github.com/charmbracelet/glow](https://github.com/charmbracelet/glow)  
Languages: `Markdown`  
Categories:   

```
:MasonInstall glow
```
# go-debug-adapter

> Go debug adapter sourced from the VSCode Go extension.

Homepage: [https://github.com/golang/vscode-go](https://github.com/golang/vscode-go)  
Languages: `Go`  
Categories: `DAP`  

```
:MasonInstall go-debug-adapter
```
# gofumpt

> A stricter gofmt.

Homepage: [https://pkg.go.dev/mvdan.cc/gofumpt](https://pkg.go.dev/mvdan.cc/gofumpt)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall gofumpt
```
# goimports

> A golang formatter which formats your code in the same style as gofmt and additionally updates your Go import lines,
adding missing ones and removing unreferenced ones.


Homepage: [https://pkg.go.dev/golang.org/x/tools/cmd/goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall goimports
```
# goimports-reviser

> Tool for Golang to sort goimports by 3-4 groups: std, general, company (optional), and project dependencies. Also,
formatting for your code will be prepared (so, you don't need to use gofmt or goimports separately). Use additional
option -rm-unused to remove unused imports and -set-alias to rewrite import aliases for versioned packages.


Homepage: [https://github.com/incu6us/goimports-reviser](https://github.com/incu6us/goimports-reviser)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall goimports-reviser
```
# golangci-lint

> golangci-lint is a fast Go linters runner. It runs linters in parallel, uses caching, supports yaml config, has
integrations with all major IDE and has dozens of linters included.


Homepage: [https://golangci-lint.run/](https://golangci-lint.run/)  
Languages: `Go`  
Categories: `Linter`  

```
:MasonInstall golangci-lint
```
# golangci-lint-langserver

> golangci-lint language server.

Homepage: [https://github.com/nametake/golangci-lint-langserver](https://github.com/nametake/golangci-lint-langserver)  
Languages: `Go`  
Categories: `LSP`  

```
:MasonInstall golangci-lint-langserver
```
# golines

> A golang formatter that fixes long lines.

Homepage: [https://github.com/segmentio/golines](https://github.com/segmentio/golines)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall golines
```
# gomodifytags

> Go tool to modify/update field tags in structs.

Homepage: [https://github.com/fatih/gomodifytags](https://github.com/fatih/gomodifytags)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall gomodifytags
```
# google-java-format

> google-java-format is a program that reformats Java source code to comply with Google Java Style.

Homepage: [https://github.com/google/google-java-format](https://github.com/google/google-java-format)  
Languages: `Java`  
Categories: `Formatter`  

```
:MasonInstall google-java-format
```
# gopls

> gopls (pronounced "Go please") is the official Go language server developed by the Go team. It provides IDE features
to any LSP-compatible editor.


Homepage: [https://pkg.go.dev/golang.org/x/tools/gopls](https://pkg.go.dev/golang.org/x/tools/gopls)  
Languages: `Go`  
Categories: `LSP`  

```
:MasonInstall gopls
```
# gospel

> misspelled word linter for Go comments, string literals and embedded files.

Homepage: [https://github.com/kortschak/gospel](https://github.com/kortschak/gospel)  
Languages: `Go`  
Categories: `Linter`  

```
:MasonInstall gospel
```
# gotests

> Gotests is a Golang commandline tool that generates table driven tests based on its target source files' function and
method signatures.


Homepage: [https://github.com/cweill/gotests](https://github.com/cweill/gotests)  
Languages: `Go`  
Categories: `Formatter`  

```
:MasonInstall gotests
```
# gotestsum

> 'go test' runner with output optimized for humans, JUnit XML for CI integration, and a summary of the test results.


Homepage: [https://github.com/gotestyourself/gotestsum](https://github.com/gotestyourself/gotestsum)  
Languages: `Go`  
Categories:   

```
:MasonInstall gotestsum
```
# gradle-language-server

> Gradle language server.

Homepage: [https://github.com/microsoft/vscode-gradle](https://github.com/microsoft/vscode-gradle)  
Languages: `Gradle`  
Categories: `LSP`  

```
:MasonInstall gradle-language-server
```
# grammarly-languageserver

> A language server implementation on top of Grammarly's SDK.

Homepage: [https://github.com/znck/grammarly](https://github.com/znck/grammarly)  
Languages: `Markdown` `Text`  
Categories: `LSP`  

```
:MasonInstall grammarly-languageserver
```
# graphql-language-service-cli

> GraphQL Language Service provides an interface for building GraphQL language services for IDEs.

Homepage: [https://www.npmjs.com/package/graphql-language-service-cli](https://www.npmjs.com/package/graphql-language-service-cli)  
Languages: `GraphQL`  
Categories: `LSP`  

```
:MasonInstall graphql-language-service-cli
```
# groovy-language-server

> A language server for Groovy.

Homepage: [https://github.com/GroovyLanguageServer/groovy-language-server](https://github.com/GroovyLanguageServer/groovy-language-server)  
Languages: `Groovy`  
Categories: `LSP`  

```
:MasonInstall groovy-language-server
```
# hadolint

> Dockerfile linter, validate inline bash, written in Haskell.

Homepage: [https://github.com/hadolint/hadolint](https://github.com/hadolint/hadolint)  
Languages: `Docker`  
Categories: `Linter`  

```
:MasonInstall hadolint
```
# haml-lint

> haml-lint is a tool to help keep your HAML files clean and readable. In addition to HAML-specific style and lint
checks, it integrates with RuboCop to bring its powerful static analysis tools to your HAML documents.


Homepage: [https://github.com/sds/haml-lint](https://github.com/sds/haml-lint)  
Languages: `HAML`  
Categories: `Linter`  

```
:MasonInstall haml-lint
```
# haskell-language-server

> Official Haskell Language Server implementation.

Homepage: [https://haskell-language-server.readthedocs.io/en/latest/](https://haskell-language-server.readthedocs.io/en/latest/)  
Languages: `Haskell`  
Categories: `LSP`  

```
:MasonInstall haskell-language-server
```
# haxe-language-server

> Language Server Protocol implementation for the Haxe language.

Homepage: [https://github.com/vshaxe/haxe-language-server](https://github.com/vshaxe/haxe-language-server)  
Languages: `Haxe`  
Categories: `LSP`  

```
:MasonInstall haxe-language-server
```
# helm-ls

> A language server that offers Helm support in early development - programmed in Go.

Homepage: [https://github.com/mrjosh/helm-ls](https://github.com/mrjosh/helm-ls)  
Languages: `Helm`  
Categories: `LSP`  

```
:MasonInstall helm-ls
```
# hoon-language-server

> Language Server for Hoon. Middleware to translate between the Language Server Protocol and your Urbit.

Homepage: [https://github.com/urbit/hoon-language-server](https://github.com/urbit/hoon-language-server)  
Languages: `Hoon`  
Categories: `LSP`  

```
:MasonInstall hoon-language-server
```
# html-lsp

> Language Server Protocol implementation for HTML.

Homepage: [https://github.com/microsoft/vscode-html-languageservice](https://github.com/microsoft/vscode-html-languageservice)  
Languages: `HTML`  
Categories: `LSP`  

```
:MasonInstall html-lsp
```
# iferr

> Go tool to generate if err != nil block for the current function.

Homepage: [https://github.com/koron/iferr](https://github.com/koron/iferr)  
Languages: `Go`  
Categories:   

```
:MasonInstall iferr
```
# impl

> impl generates method stubs for implementing an interface.

Homepage: [https://github.com/josharian/impl](https://github.com/josharian/impl)  
Languages: `Go`  
Categories:   

```
:MasonInstall impl
```
# intelephense

> Professional PHP tooling for any Language Server Protocol capable editor.

Homepage: [https://intelephense.com](https://intelephense.com)  
Languages: `PHP`  
Categories: `LSP`  

```
:MasonInstall intelephense
```
# isort

> isort is a Python utility / library to sort imports alphabetically.

Homepage: [https://pypi.org/project/isort/](https://pypi.org/project/isort/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall isort
```
# java-debug-adapter

> The debug server implementation for Java. It conforms to the debugger adapter protocol.

Homepage: [https://github.com/microsoft/java-debug](https://github.com/microsoft/java-debug)  
Languages: `Java`  
Categories: `DAP`  

```
:MasonInstall java-debug-adapter
```
# java-language-server

> Java language server using the Java compiler API.

Homepage: [https://github.com/georgewfraser/java-language-server](https://github.com/georgewfraser/java-language-server)  
Languages: `Java`  
Categories: `LSP` `DAP`  

```
:MasonInstall java-language-server
```
# java-test

> The Test Runner for Java works with java-debug-adapter to provide the following features:
- Run/Debug test cases
- Customize test configurations
- View test report
- View tests in Test Explorer

Enables support for the following test frameworks:

- JUnit 4 (v4.8.0+)
- JUnit 5 (v5.1.0+)
- TestNG (v6.8.0+)


Homepage: [https://github.com/microsoft/vscode-java-test](https://github.com/microsoft/vscode-java-test)  
Languages: `Java`  
Categories: `DAP`  

```
:MasonInstall java-test
```
# jdtls

> Java language server.

Homepage: [https://github.com/eclipse/eclipse.jdt.ls](https://github.com/eclipse/eclipse.jdt.ls)  
Languages: `Java`  
Categories: `LSP`  

```
:MasonInstall jdtls
```
# jedi-language-server

> A Python language server exclusively for Jedi. If Jedi supports it well, this language server should too.

Homepage: [https://github.com/pappasam/jedi-language-server](https://github.com/pappasam/jedi-language-server)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall jedi-language-server
```
# joker

> Small Clojure interpreter, linter and formatter.

Homepage: [https://github.com/candid82/joker](https://github.com/candid82/joker)  
Languages: `Clojure` `ClojureScript`  
Categories: `Formatter` `Linter`  

```
:MasonInstall joker
```
# jq

> Command-line JSON processor.

Homepage: [https://github.com/stedolan/jq](https://github.com/stedolan/jq)  
Languages: `JSON`  
Categories: `Formatter`  

```
:MasonInstall jq
```
# jq-lsp

> jq-lsp is a language server for the jq language, developed by Mattias Wadman. It provides IDE features to any
LSP-compatible editor.


Homepage: [https://github.com/wader/jq-lsp](https://github.com/wader/jq-lsp)  
Languages: `Jq`  
Categories: `LSP`  

```
:MasonInstall jq-lsp
```
# js-debug-adapter

> The VS Code JavaScript debugger.

Homepage: [https://github.com/microsoft/vscode-js-debug](https://github.com/microsoft/vscode-js-debug)  
Languages: `JavaScript` `TypeScript`  
Categories: `DAP`  

```
:MasonInstall js-debug-adapter
```
# json-lsp

> Language Server Protocol implementation for JSON.

Homepage: [https://github.com/microsoft/vscode-json-languageservice](https://github.com/microsoft/vscode-json-languageservice)  
Languages: `JSON`  
Categories: `LSP`  

```
:MasonInstall json-lsp
```
# json-to-struct

> A simple command-line tool for generating to struct definitions from JSON.

Homepage: [https://github.com/tmc/json-to-struct](https://github.com/tmc/json-to-struct)  
Languages: `Go`  
Categories:   

```
:MasonInstall json-to-struct
```
# jsonlint

> A pure JavaScript version of the service provided at jsonlint.com.

Homepage: [https://github.com/zaach/jsonlint](https://github.com/zaach/jsonlint)  
Languages: `JSON`  
Categories: `Linter`  

```
:MasonInstall jsonlint
```
# jsonnet-language-server

> A Language Server Protocol (LSP) server for Jsonnet (https://jsonnet.org).

Homepage: [https://github.com/grafana/jsonnet-language-server](https://github.com/grafana/jsonnet-language-server)  
Languages: `Jsonnet`  
Categories: `LSP`  

```
:MasonInstall jsonnet-language-server
```
# julia-lsp

> An implementation of the Microsoft Language Server Protocol for the Julia language.

Homepage: [https://github.com/julia-vscode/LanguageServer.jl](https://github.com/julia-vscode/LanguageServer.jl)  
Languages: `Julia`  
Categories: `LSP`  

```
:MasonInstall julia-lsp
```
# kotlin-debug-adapter

> Kotlin/JVM debugging for any editor/IDE using the Debug Adapter Protocol.

Homepage: [https://github.com/fwcd/kotlin-debug-adapter](https://github.com/fwcd/kotlin-debug-adapter)  
Languages: `Kotlin`  
Categories: `DAP`  

```
:MasonInstall kotlin-debug-adapter
```
# kotlin-language-server

> Kotlin code completion, linting and more for any editor/IDE using the Language Server Protocol.

Homepage: [https://github.com/fwcd/kotlin-language-server](https://github.com/fwcd/kotlin-language-server)  
Languages: `Kotlin`  
Categories: `LSP`  

```
:MasonInstall kotlin-language-server
```
# ktlint

> An anti-bikeshedding Kotlin linter with built-in formatter.

Homepage: [https://github.com/pinterest/ktlint](https://github.com/pinterest/ktlint)  
Languages: `Kotlin`  
Categories: `Formatter` `Linter`  

```
:MasonInstall ktlint
```
# latexindent

> latexindent.pl is a perl script to beautify/tidy/format/indent (add horizontal leading space to) code within
environments, commands, after headings and within special code blocks.


Homepage: [https://github.com/cmhughes/latexindent.pl](https://github.com/cmhughes/latexindent.pl)  
Languages: `LaTeX`  
Categories: `Formatter`  

```
:MasonInstall latexindent
```
# lelwel

> LL(1) parser generator for Rust.

Homepage: [https://github.com/0x2a-42/lelwel](https://github.com/0x2a-42/lelwel)  
Languages: `Lelwel`  
Categories: `LSP`  

```
:MasonInstall lelwel
```
# lemminx

> XML Language Server.

Homepage: [https://github.com/eclipse/lemminx](https://github.com/eclipse/lemminx)  
Languages: `XML`  
Categories: `LSP`  

```
:MasonInstall lemminx
```
# lemmy-help

> Every one needs help, so lemmy-help you! A CLI to generate vim/nvim help doc from emmylua.

Homepage: [https://github.com/numToStr/lemmy-help](https://github.com/numToStr/lemmy-help)  
Languages: `Lua`  
Categories:   

```
:MasonInstall lemmy-help
```
# ltex-ls

> LTeX Language Server: LSP language server for LanguageTool 🔍✔️ with support for LaTeX 🎓, Markdown 📝, and others.


Homepage: [https://valentjn.github.io/ltex/](https://valentjn.github.io/ltex/)  
Languages: `Text` `Markdown` `LaTeX`  
Categories: `LSP`  

```
:MasonInstall ltex-ls
```
# lua-language-server

> A language server that offers Lua language support - programmed in Lua.

Homepage: [https://github.com/LuaLS/lua-language-server](https://github.com/LuaLS/lua-language-server)  
Languages: `Lua`  
Categories: `LSP`  

```
:MasonInstall lua-language-server
```
# luacheck

> A tool for linting and static analysis of Lua code.

Homepage: [https://github.com/mpeterv/luacheck](https://github.com/mpeterv/luacheck)  
Languages: `Lua`  
Categories: `Linter`  

```
:MasonInstall luacheck
```
# luaformatter

> Code formatter for Lua.

Homepage: [https://github.com/Koihik/LuaFormatter](https://github.com/Koihik/LuaFormatter)  
Languages: `Lua`  
Categories: `Formatter`  

```
:MasonInstall luaformatter
```
# luau-lsp

> An implementation of a language server for the Luau programming language.

Homepage: [https://github.com/JohnnyMorganz/luau-lsp](https://github.com/JohnnyMorganz/luau-lsp)  
Languages: `Luau`  
Categories: `LSP`  

```
:MasonInstall luau-lsp
```
# markdown-toc

> API and CLI for generating a markdown TOC (table of contents) for a README or any markdown files.

Homepage: [https://github.com/jonschlinkert/markdown-toc](https://github.com/jonschlinkert/markdown-toc)  
Languages: `Markdown`  
Categories: `Formatter`  

```
:MasonInstall markdown-toc
```
# markdownlint

> A Node.js style checker and lint tool for Markdown/CommonMark files.

Homepage: [https://github.com/igorshubovych/markdownlint-cli](https://github.com/igorshubovych/markdownlint-cli)  
Languages: `Markdown`  
Categories: `Linter` `Formatter`  

```
:MasonInstall markdownlint
```
# marksman

> Markdown LSP server providing completion, cross-references, diagnostics, and more.

Homepage: [https://github.com/artempyanykh/marksman](https://github.com/artempyanykh/marksman)  
Languages: `Markdown`  
Categories: `LSP`  

```
:MasonInstall marksman
```
# metamath-zero-lsp

> An MM0/MM1 server written in Rust.

Homepage: [https://github.com/digama0/mm0](https://github.com/digama0/mm0)  
Languages: `Metamath Zero`  
Categories: `LSP`  

```
:MasonInstall metamath-zero-lsp
```
# millet

> A language server for Standard ML.

Homepage: [https://github.com/azdavis/millet](https://github.com/azdavis/millet)  
Languages: `Standard ML`  
Categories: `LSP`  

```
:MasonInstall millet
```
# misspell

> Correct commonly misspelled English words in source files.

Homepage: [https://github.com/client9/misspell](https://github.com/client9/misspell)  
Languages:   
Categories: `Linter`  

```
:MasonInstall misspell
```
# mockdebug

> Mock Debug simulates a debug adapter. It supports step, continue, breakpoints, exceptions, and variable access but it
is not connected to any real debugger.


Homepage: [https://github.com/microsoft/vscode-mock-debug](https://github.com/microsoft/vscode-mock-debug)  
Languages:   
Categories: `DAP`  

```
:MasonInstall mockdebug
```
# move-analyzer

> move-analyzer is a language server implementation for the Move programming language.

Homepage: [https://github.com/move-language/move](https://github.com/move-language/move)  
Languages: `Move`  
Categories: `LSP`  

```
:MasonInstall move-analyzer
```
# mypy

> Mypy is a static type checker for Python.

Homepage: [https://github.com/python/mypy](https://github.com/python/mypy)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall mypy
```
# neocmakelsp

> CMake LSP implementation based on Tower and Tree-sitter.

Homepage: [https://github.com/Decodetalkers/neocmakelsp](https://github.com/Decodetalkers/neocmakelsp)  
Languages: `CMake`  
Categories: `LSP`  

```
:MasonInstall neocmakelsp
```
# netcoredbg

> NetCoreDbg is a managed code debugger with MI interface for CoreCLR.

Homepage: [https://github.com/Samsung/netcoredbg](https://github.com/Samsung/netcoredbg)  
Languages: `.NET` `C#` `F#`  
Categories: `DAP`  

```
:MasonInstall netcoredbg
```
# nginx-language-server

> A language server for nginx configuration files.

Homepage: [https://github.com/pappasam/nginx-language-server](https://github.com/pappasam/nginx-language-server)  
Languages: `Nginx`  
Categories: `LSP`  

```
:MasonInstall nginx-language-server
```
# nickel-lang-lsp

> The Nickel Language Server (NLS) is a language server for the Nickel programming language. NLS offers error messages,
type hints, and auto-completion right in your favorite LSP-enabled editor.


Homepage: [https://nickel-lang.org/](https://nickel-lang.org/)  
Languages: `Nickel`  
Categories: `LSP`  

```
:MasonInstall nickel-lang-lsp
```
# nil

> Language Server for Nix.

Homepage: [https://github.com/oxalica/nil](https://github.com/oxalica/nil)  
Languages: `Nix`  
Categories: `LSP`  

```
:MasonInstall nil
```
# nimlsp

> Language Server Protocol implementation for Nim.

Homepage: [https://github.com/PMunch/nimlsp](https://github.com/PMunch/nimlsp)  
Languages: `Nim`  
Categories: `LSP`  

```
:MasonInstall nimlsp
```
# node-debug2-adapter

> A debug adapter that supports debugging Node via the Chrome Debugging Protocol. No longer maintained.

Homepage: [https://github.com/microsoft/vscode-node-debug2](https://github.com/microsoft/vscode-node-debug2)  
Languages: `JavaScript` `TypeScript`  
Categories: `DAP`  

```
:MasonInstall node-debug2-adapter
```
# nxls

> A language server that provides code completion and more for Nx workspaces.

Homepage: [https://github.com/nrwl/nx-console/tree/master/apps/nxls](https://github.com/nrwl/nx-console/tree/master/apps/nxls)  
Languages: `JSON`  
Categories: `LSP`  

```
:MasonInstall nxls
```
# ocaml-lsp

> OCaml Language Server Protocol implementation.

Homepage: [https://github.com/ocaml/ocaml-lsp](https://github.com/ocaml/ocaml-lsp)  
Languages: `OCaml`  
Categories: `LSP`  

```
:MasonInstall ocaml-lsp
```
# ocamlformat

> ocamlformat is a tool for formatting OCaml code. It automatically adjusts the layout of your code to follow the
recommended style guidelines, making it easier to read and understand.


Homepage: [https://github.com/ocaml-ppx/ocamlformat](https://github.com/ocaml-ppx/ocamlformat)  
Languages: `OCaml`  
Categories: `Formatter`  

```
:MasonInstall ocamlformat
```
# ols

> Language server for Odin. This project is still in early development.

Homepage: [https://github.com/DanielGavin/ols](https://github.com/DanielGavin/ols)  
Languages: `Odin`  
Categories: `LSP`  

```
:MasonInstall ols
```
# omnisharp

> OmniSharp language server based on Roslyn workspaces. This version of Omnisharp requires dotnet (.NET 6.0) to be
installed.


Homepage: [https://github.com/OmniSharp/omnisharp-roslyn](https://github.com/OmniSharp/omnisharp-roslyn)  
Languages: `C#`  
Categories: `LSP`  

```
:MasonInstall omnisharp
```
# omnisharp-mono

> OmniSharp language server based on Roslyn workspaces. This version of Omnisharp requires Mono to be installed on Linux
& macOS.


Homepage: [https://github.com/OmniSharp/omnisharp-roslyn](https://github.com/OmniSharp/omnisharp-roslyn)  
Languages: `C#`  
Categories: `LSP`  

```
:MasonInstall omnisharp-mono
```
# opencl-language-server

> Provides an OpenCL kernel diagnostics.

Homepage: [https://github.com/Galarius/opencl-language-server](https://github.com/Galarius/opencl-language-server)  
Languages: `OpenCL`  
Categories: `LSP`  

```
:MasonInstall opencl-language-server
```
# openedge-language-server

> OpenEdge Language Server.

Homepage: [https://github.com/vscode-abl/vscode-abl](https://github.com/vscode-abl/vscode-abl)  
Languages: `Progress` `OpenEdge`  
Categories: `LSP`  

```
:MasonInstall openedge-language-server
```
# openscad-lsp

> Language Server Protocol implementation for OpenSCAD, written in Rust.

Homepage: [https://github.com/Leathong/openscad-LSP](https://github.com/Leathong/openscad-LSP)  
Languages: `OpenSCAD`  
Categories: `LSP`  

```
:MasonInstall openscad-lsp
```
# perlnavigator

> Perl Language Server that includes perl critic and code navigation.

Homepage: [https://github.com/bscan/PerlNavigator](https://github.com/bscan/PerlNavigator)  
Languages: `Perl`  
Categories: `LSP`  

```
:MasonInstall perlnavigator
```
# php-cs-fixer

> The PHP Coding Standards Fixer (PHP CS Fixer) tool fixes your code to follow standards; whether you want to follow PHP
coding standards as defined in the PSR-1, PSR-2, etc., or other community driven ones like the Symfony one. You can
also define your (team's) style through configuration.


Homepage: [https://github.com/PHP-CS-Fixer/PHP-CS-Fixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer)  
Languages: `PHP`  
Categories: `Formatter`  

```
:MasonInstall php-cs-fixer
```
# php-debug-adapter

> PHP Debug Adapter 🐞⛔.

Homepage: [https://github.com/xdebug/vscode-php-debug](https://github.com/xdebug/vscode-php-debug)  
Languages: `PHP`  
Categories: `DAP`  

```
:MasonInstall php-debug-adapter
```
# phpactor

> Phpactor is an intelligent Completion and Refactoring tool for PHP which is available over it’s own RPC protocol and
as a Language Server.


Homepage: [https://phpactor.readthedocs.io/en/master/](https://phpactor.readthedocs.io/en/master/)  
Languages: `PHP`  
Categories: `LSP`  

```
:MasonInstall phpactor
```
# phpcbf

> phpcbf automatically corrects coding standard violations that would be detected by phpcs.

Homepage: [https://github.com/squizlabs/PHP_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer)  
Languages: `PHP`  
Categories: `Formatter`  

```
:MasonInstall phpcbf
```
# phpcs

> phpcs tokenizes PHP, JavaScript and CSS files to detect violations of a defined standard.

Homepage: [https://github.com/squizlabs/PHP_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer)  
Languages: `PHP`  
Categories: `Linter`  

```
:MasonInstall phpcs
```
# phpmd

> PHPMD is a spin-off project of PHP Depend and aims to be a PHP equivalent of the well known Java tool PMD. PHPMD can
be seen as an user friendly frontend application for the raw metrics stream measured by PHP Depend.


Homepage: [https://github.com/phpmd/phpmd](https://github.com/phpmd/phpmd)  
Languages: `PHP`  
Categories: `Linter`  

```
:MasonInstall phpmd
```
# phpstan

> PHP Static Analysis Tool - discover bugs in your code without running it!

Homepage: [https://github.com/phpstan/phpstan](https://github.com/phpstan/phpstan)  
Languages: `PHP`  
Categories: `Linter`  

```
:MasonInstall phpstan
```
# pint

> Laravel Pint is an opinionated PHP code style fixer for minimalists.

Homepage: [https://laravel.com/docs/pint](https://laravel.com/docs/pint)  
Languages: `PHP`  
Categories: `Formatter`  

```
:MasonInstall pint
```
# powershell-editor-services

> A common platform for PowerShell development support in any editor or application.

Homepage: [https://github.com/PowerShell/PowerShellEditorServices](https://github.com/PowerShell/PowerShellEditorServices)  
Languages: `PowerShell`  
Categories: `LSP`  

```
:MasonInstall powershell-editor-services
```
# prettier

> Prettier is an opinionated code formatter.

Homepage: [https://prettier.io](https://prettier.io)  
Languages: `Angular` `CSS` `Flow` `GraphQL` `HTML` `JSON` `JSX` `JavaScript` `LESS` `Markdown` `SCSS` `TypeScript` `Vue` `YAML`  
Categories: `Formatter`  

```
:MasonInstall prettier
```
# prettierd

> Prettier, as a daemon, for ludicrous formatting speed.

Homepage: [https://github.com/fsouza/prettierd](https://github.com/fsouza/prettierd)  
Languages: `Angular` `CSS` `Flow` `GraphQL` `HTML` `JSON` `JSX` `JavaScript` `LESS` `Markdown` `SCSS` `TypeScript` `Vue` `YAML`  
Categories: `Formatter`  

```
:MasonInstall prettierd
```
# prisma-language-server

> Any editor that is compatible with the Language Server Protocol can create clients that can use the features provided
by this language server.


Homepage: [https://github.com/prisma/language-tools](https://github.com/prisma/language-tools)  
Languages: `Prisma`  
Categories: `LSP`  

```
:MasonInstall prisma-language-server
```
# proselint

> proselint is a linter for English prose. It places the world's greatest writers and editors by your side, where they
whisper suggestions on how to improve your prose.


Homepage: [https://github.com/amperser/proselint](https://github.com/amperser/proselint)  
Languages: `Text` `Markdown`  
Categories: `Linter`  

```
:MasonInstall proselint
```
# prosemd-lsp

> An experimental proofreading and linting language server for markdown files.

Homepage: [https://github.com/kitten/prosemd-lsp](https://github.com/kitten/prosemd-lsp)  
Languages: `Markdown`  
Categories: `LSP`  

```
:MasonInstall prosemd-lsp
```
# protolint

> protolint is the pluggable linting/fixing utility for Protocol Buffer files (proto2+proto3).

Homepage: [https://github.com/yoheimuta/protolint](https://github.com/yoheimuta/protolint)  
Languages: `Protobuf`  
Categories: `Linter`  

```
:MasonInstall protolint
```
# psalm

> A static analysis tool for finding errors in PHP applications.

Homepage: [https://psalm.dev/](https://psalm.dev/)  
Languages: `PHP`  
Categories: `LSP`  

```
:MasonInstall psalm
```
# puppet-editor-services

> Puppet Language Server for editors.

Homepage: [https://github.com/puppetlabs/puppet-editor-services](https://github.com/puppetlabs/puppet-editor-services)  
Languages: `Puppet`  
Categories: `LSP` `DAP`  

```
:MasonInstall puppet-editor-services
```
# purescript-language-server

> Node-based Language Server Protocol server for PureScript based on the PureScript IDE server (aka psc-ide / purs ide
server). Used as the vscode plugin backend but should be compatible with other Language Server Client implementations.


Homepage: [https://github.com/nwolverson/purescript-language-server](https://github.com/nwolverson/purescript-language-server)  
Languages: `PureScript`  
Categories: `LSP`  

```
:MasonInstall purescript-language-server
```
# pydocstyle

> pydocstyle is a static analysis tool for checking compliance with Python docstring conventions.

Homepage: [https://www.pydocstyle.org/](https://www.pydocstyle.org/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall pydocstyle
```
# pyflakes

> A simple program which checks Python source files for errors.

Pyflakes analyzes programs and detects various errors. It works by parsing the source file, not importing it, so it is
safe to use on modules with side effects. It’s also much faster.


Homepage: [https://pypi.org/project/pyflakes/](https://pypi.org/project/pyflakes/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall pyflakes
```
# pylama

> Code audit tool for Python.

Homepage: [https://klen.github.io/pylama/](https://klen.github.io/pylama/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall pylama
```
# pylint

> Pylint is a static code analyser for Python 2 or 3.

Homepage: [https://pypi.org/project/pylint/](https://pypi.org/project/pylint/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall pylint
```
# pylyzer

> A fast static code analyzer & language server for Python.

Homepage: [https://github.com/mtshiba/pylyzer](https://github.com/mtshiba/pylyzer)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall pylyzer
```
# pyproject-flake8

> A monkey patching wrapper to connect flake8 with pyproject.toml configuration.

Homepage: [https://github.com/csachs/pyproject-flake8](https://github.com/csachs/pyproject-flake8)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall pyproject-flake8
```
# pyre

> Pyre is a performant type checker for Python compliant with PEP 484.

Homepage: [https://pypi.org/project/pyre-check/](https://pypi.org/project/pyre-check/)  
Languages: `Python`  
Categories: `LSP` `Linter`  

```
:MasonInstall pyre
```
# pyright

> Static type checker for Python.

Homepage: [https://github.com/microsoft/pyright](https://github.com/microsoft/pyright)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall pyright
```
# python-lsp-server

> Fork of the python-language-server project, maintained by the Spyder IDE team and the community.

Homepage: [https://github.com/python-lsp/python-lsp-server](https://github.com/python-lsp/python-lsp-server)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall python-lsp-server
```
# quick-lint-js

> Over 130× faster than ESLint, quick-lint-js gives you instant feedback as you code. Find bugs in your JavaScript
before your finger leaves the keyboard. Lint any JavaScript file with no configuration.


Homepage: [https://quick-lint-js.com/](https://quick-lint-js.com/)  
Languages: `JavaScript`  
Categories: `LSP` `Linter`  

```
:MasonInstall quick-lint-js
```
# r-languageserver

> An implementation of the Language Server Protocol for R

Homepage: [https://github.com/REditorSupport/languageserver](https://github.com/REditorSupport/languageserver)  
Languages: `R`  
Categories: `LSP`  

```
:MasonInstall r-languageserver
```
# raku-navigator

> Raku Language Server that includes Raku critic and code navigation.

Homepage: [https://github.com/bscan/RakuNavigator](https://github.com/bscan/RakuNavigator)  
Languages: `Raku`  
Categories: `LSP`  

```
:MasonInstall raku-navigator
```
# reason-language-server

> A language server for reason, in reason.

Homepage: [https://github.com/jaredly/reason-language-server](https://github.com/jaredly/reason-language-server)  
Languages: `Reason`  
Categories: `LSP`  

```
:MasonInstall reason-language-server
```
# remark-cli

> Command line interface to inspect and change markdown files with remark.

Homepage: [https://remark.js.org/](https://remark.js.org/)  
Languages: `Markdown`  
Categories: `Formatter`  

```
:MasonInstall remark-cli
```
# remark-language-server

> A language server to lint and format markdown files with remark.

Homepage: [https://github.com/remarkjs/remark-language-server](https://github.com/remarkjs/remark-language-server)  
Languages: `Markdown`  
Categories: `LSP`  

```
:MasonInstall remark-language-server
```
# reorder-python-imports

> Tool for automatically reordering python imports. Similar to isort but uses static analysis more.

Homepage: [https://github.com/asottile/reorder_python_imports](https://github.com/asottile/reorder_python_imports)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall reorder-python-imports
```
# rescript-lsp

> Language Server for ReScript.

Homepage: [https://github.com/rescript-lang/rescript-vscode](https://github.com/rescript-lang/rescript-vscode)  
Languages: `ReScript`  
Categories: `LSP`  

```
:MasonInstall rescript-lsp
```
# revive

> ~6x faster, stricter, configurable, extensible, and beautiful drop-in replacement for golint.

Homepage: [https://github.com/mgechev/revive](https://github.com/mgechev/revive)  
Languages: `Go`  
Categories: `Linter`  

```
:MasonInstall revive
```
# rnix-lsp

> Language Server for Nix.

Homepage: [https://github.com/nix-community/rnix-lsp](https://github.com/nix-community/rnix-lsp)  
Languages: `Nix`  
Categories: `LSP`  

```
:MasonInstall rnix-lsp
```
# robotframework-lsp

> Language Server Protocol implementation for Robot Framework.

Homepage: [https://github.com/robocorp/robotframework-lsp](https://github.com/robocorp/robotframework-lsp)  
Languages: `Robot Framework`  
Categories: `LSP`  

```
:MasonInstall robotframework-lsp
```
# rome

> Rome is a formatter, linter, bundler, and more for JavaScript, TypeScript, JSON, HTML, Markdown, and CSS.

Homepage: [https://rome.tools](https://rome.tools)  
Languages: `CSS` `HTML` `JSON` `JavaScript` `Markdown` `TypeScript`  
Categories: `LSP` `Linter`  

```
:MasonInstall rome
```
# rstcheck

> Checks syntax of reStructuredText and code blocks nested within it.

Homepage: [https://rstcheck.readthedocs.io/](https://rstcheck.readthedocs.io/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall rstcheck
```
# rubocop

> The Ruby Linter/Formatter that Serves and Protects.

Homepage: [https://rubocop.org](https://rubocop.org)  
Languages: `Ruby`  
Categories: `Formatter` `Linter`  

```
:MasonInstall rubocop
```
# ruby-lsp

> This gem is an implementation of the language server protocol specification for Ruby, used to improve editor features.


Homepage: [https://github.com/Shopify/ruby-lsp](https://github.com/Shopify/ruby-lsp)  
Languages: `Ruby`  
Categories: `LSP`  

```
:MasonInstall ruby-lsp
```
# ruff

> An extremely fast Python linter, written in Rust.

Homepage: [https://github.com/charliermarsh/ruff/](https://github.com/charliermarsh/ruff/)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall ruff
```
# ruff-lsp

> A Language Server Protocol implementation for Ruff - An extremely fast Python linter, written in Rust.

Homepage: [https://github.com/charliermarsh/ruff-lsp/](https://github.com/charliermarsh/ruff-lsp/)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall ruff-lsp
```
# rust-analyzer

> rust-analyzer is an implementation of the Language Server Protocol for the
Rust programming language. It provides features like completion and goto
definition for many code editors, including VS Code, Emacs and Vim.


Homepage: [https://github.com/rust-lang/rust-analyzer](https://github.com/rust-lang/rust-analyzer)  
Languages: `Rust`  
Categories: `LSP`  

```
:MasonInstall rust-analyzer
```
# rustfmt

> A tool for formatting Rust code according to style guidelines.

Homepage: [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)  
Languages: `Rust`  
Categories: `Formatter`  

```
:MasonInstall rustfmt
```
# rustywind

> CLI for organizing Tailwind CSS classes.

Homepage: [https://github.com/avencera/rustywind](https://github.com/avencera/rustywind)  
Languages: `Angular` `HTML` `JSX` `JavaScript` `TypeScript` `Vue`  
Categories: `Formatter`  

```
:MasonInstall rustywind
```
# salt-lsp

> Salt Language Server Protocol Server.

Homepage: [https://github.com/dcermak/salt-lsp](https://github.com/dcermak/salt-lsp)  
Languages: `Salt`  
Categories: `LSP`  

```
:MasonInstall salt-lsp
```
# selene

> A blazing-fast modern Lua linter written in Rust.

Homepage: [https://kampfkarren.github.io/selene/](https://kampfkarren.github.io/selene/)  
Languages: `Lua` `Luau`  
Categories: `Linter`  

```
:MasonInstall selene
```
# semgrep

> Semgrep is a fast, open-source, static analysis engine for finding bugs, detecting vulnerabilities in third-party
dependencies, and enforcing code standards.


Homepage: [https://github.com/returntocorp/semgrep](https://github.com/returntocorp/semgrep)  
Languages: `C#` `Go` `JSON` `Java` `JavaScript` `PHP` `Python` `Ruby` `Scala` `TypeScript`  
Categories: `Linter`  

```
:MasonInstall semgrep
```
# serve-d

> Microsoft language server protocol implementation for D using workspace-d.

Homepage: [https://github.com/Pure-D/serve-d](https://github.com/Pure-D/serve-d)  
Languages: `D`  
Categories: `LSP`  

```
:MasonInstall serve-d
```
# shellcheck

> ShellCheck, a static analysis tool for shell scripts.

Homepage: [https://www.shellcheck.net/](https://www.shellcheck.net/)  
Languages: `Bash`  
Categories: `Linter`  

```
:MasonInstall shellcheck
```
# shellharden

> The corrective bash syntax highlighter.

Homepage: [https://github.com/anordal/shellharden](https://github.com/anordal/shellharden)  
Languages: `Bash`  
Categories: `Formatter` `Linter`  

```
:MasonInstall shellharden
```
# shfmt

> A shell formatter (sh/bash/mksh).

Homepage: [https://github.com/mvdan/sh](https://github.com/mvdan/sh)  
Languages: `Bash` `Mksh` `Shell`  
Categories: `Formatter`  

```
:MasonInstall shfmt
```
# shopify-theme-check

> The Ultimate Shopify Theme Linter.

Homepage: [https://github.com/Shopify/theme-check](https://github.com/Shopify/theme-check)  
Languages: `Liquid`  
Categories: `LSP` `Linter`  

```
:MasonInstall shopify-theme-check
```
# slint-lsp

> A LSP Server that adds features like auto-complete and live preview of the .slint files to many editors.

Homepage: [https://slint-ui.com/](https://slint-ui.com/)  
Languages: `Slint`  
Categories: `LSP`  

```
:MasonInstall slint-lsp
```
# smithy-language-server

> A Language Server Protocol implementation for the Smithy IDL.

Homepage: [https://github.com/awslabs/smithy-language-server](https://github.com/awslabs/smithy-language-server)  
Languages: `Smithy`  
Categories: `LSP`  

```
:MasonInstall smithy-language-server
```
# snakefmt

> The uncompromising Snakemake code formatter.

Homepage: [https://github.com/snakemake/snakefmt](https://github.com/snakemake/snakefmt)  
Languages: `Snakemake`  
Categories: `Formatter`  

```
:MasonInstall snakefmt
```
# solang

> Solidity Compiler for Solana, Substrate, and ewasm.

Homepage: [https://solang.readthedocs.io/en/latest/](https://solang.readthedocs.io/en/latest/)  
Languages: `Solidity`  
Categories: `LSP` `Compiler`  

```
:MasonInstall solang
```
# solang-llvm

> Solang requires Solana's LLVM fork. We provide pre-built binaries compatible with Solang.

Homepage: [https://github.com/hyperledger/solang-llvm](https://github.com/hyperledger/solang-llvm)  
Languages: `Solidity`  
Categories: `LSP` `Compiler`  

```
:MasonInstall solang-llvm
```
# solargraph

> Solargraph is a Ruby gem that provides intellisense features through the language server protocol.

Homepage: [https://solargraph.org](https://solargraph.org)  
Languages: `Ruby`  
Categories: `LSP`  

```
:MasonInstall solargraph
```
# solhint

> Solhint is a linting utility for Solidity code.

Homepage: [https://protofire.github.io/solhint/](https://protofire.github.io/solhint/)  
Languages: `Solidity`  
Categories: `Linter`  

```
:MasonInstall solhint
```
# solidity

> Solidity, the Smart Contract Programming Language.

Homepage: [https://github.com/ethereum/solidity](https://github.com/ethereum/solidity)  
Languages: `Solidity`  
Categories: `Compiler` `LSP`  

```
:MasonInstall solidity
```
# solidity-ls

> Solidity language server.

Homepage: [https://github.com/qiuxiang/solidity-ls](https://github.com/qiuxiang/solidity-ls)  
Languages: `Solidity`  
Categories: `LSP`  

```
:MasonInstall solidity-ls
```
# sorbet

> Sorbet is a fast, powerful type checker designed for Ruby.

Homepage: [https://sorbet.org/](https://sorbet.org/)  
Languages: `Ruby`  
Categories: `LSP`  

```
:MasonInstall sorbet
```
# sourcery

> Sourcery is a tool available in your IDE, GitHub, or as a CLI that suggests refactoring improvements to help make your
code more readable and generally higher quality.


Homepage: [https://docs.sourcery.ai/](https://docs.sourcery.ai/)  
Languages: `Python`  
Categories: `LSP`  

```
:MasonInstall sourcery
```
# spectral-language-server

> Awesome Spectral JSON/YAML linter with OpenAPI/AsyncAPI support. Spectral is a flexible object linter with out of the
box support for OpenAPI v2 and v3, JSON Schema, and AsyncAPI.


Homepage: [https://github.com/stoplightio/vscode-spectral](https://github.com/stoplightio/vscode-spectral)  
Languages: `JSON` `YAML`  
Categories: `LSP`  

```
:MasonInstall spectral-language-server
```
# sql-formatter

> A whitespace formatter for different query languages.

Homepage: [https://sql-formatter-org.github.io/sql-formatter/](https://sql-formatter-org.github.io/sql-formatter/)  
Languages: `SQL`  
Categories: `Formatter`  

```
:MasonInstall sql-formatter
```
# sqlfluff

> SQLFluff is a dialect-flexible and configurable SQL linter.

Homepage: [https://github.com/sqlfluff/sqlfluff](https://github.com/sqlfluff/sqlfluff)  
Languages: `SQL`  
Categories: `Linter`  

```
:MasonInstall sqlfluff
```
# sqlfmt

> sqlfmt formats your dbt SQL files so you don't have to. It is similar in nature to black, gofmt, and rustfmt (but for SQL).

Homepage: [https://sqlfmt.com/](https://sqlfmt.com/)  
Languages: `SQL`  
Categories: `Formatter`  

```
:MasonInstall sqlfmt
```
# sqlls

> SQL Language Server.

Homepage: [https://github.com/joe-re/sql-language-server](https://github.com/joe-re/sql-language-server)  
Languages: `SQL`  
Categories: `LSP`  

```
:MasonInstall sqlls
```
# sqls

> SQL language server written in Go.

Homepage: [https://github.com/lighttiger2505/sqls](https://github.com/lighttiger2505/sqls)  
Languages: `SQL`  
Categories: `LSP`  

```
:MasonInstall sqls
```
# standardrb

> Ruby Style Guide, with linter and automatic code fixer.

Homepage: [https://github.com/testdouble/standard/](https://github.com/testdouble/standard/)  
Languages: `Ruby`  
Categories: `Formatter` `Linter`  

```
:MasonInstall standardrb
```
# staticcheck

> The advanced Go linter.

Homepage: [https://staticcheck.io/](https://staticcheck.io/)  
Languages: `Go`  
Categories: `Linter`  

```
:MasonInstall staticcheck
```
# stylelint

> A mighty CSS linter that helps you avoid errors and enforce conventions.

Homepage: [https://stylelint.io](https://stylelint.io)  
Languages: `CSS` `Sass` `SCSS` `LESS`  
Categories: `Linter`  

```
:MasonInstall stylelint
```
# stylelint-lsp

> A stylelint Language Server.

Homepage: [https://github.com/bmatcuk/stylelint-lsp](https://github.com/bmatcuk/stylelint-lsp)  
Languages: `Stylelint`  
Categories: `LSP`  

```
:MasonInstall stylelint-lsp
```
# stylua

> An opinionated Lua code formatter.

Homepage: [https://github.com/JohnnyMorganz/StyLua](https://github.com/JohnnyMorganz/StyLua)  
Languages: `Lua` `Luau`  
Categories: `Formatter`  

```
:MasonInstall stylua
```
# svelte-language-server

> A language server (implementing the language server protocol) for Svelte.

Homepage: [https://github.com/sveltejs/language-tools](https://github.com/sveltejs/language-tools)  
Languages: `Svelte`  
Categories: `LSP`  

```
:MasonInstall svelte-language-server
```
# svlangserver

> A language server for systemverilog that has been tested to work with coc.nvim, VSCode, Sublime Text 4, emacs, and
Neovim.


Homepage: [https://github.com/imc-trading/svlangserver](https://github.com/imc-trading/svlangserver)  
Languages: `SystemVerilog`  
Categories: `LSP`  

```
:MasonInstall svlangserver
```
# svls

> SystemVerilog language server

Homepage: [https://github.com/dalance/svls](https://github.com/dalance/svls)  
Languages: `SystemVerilog`  
Categories: `LSP`  

```
:MasonInstall svls
```
# tailwindcss-language-server

> Language Server Protocol implementation for Tailwind CSS.

Homepage: [https://github.com/tailwindlabs/tailwindcss-intellisense](https://github.com/tailwindlabs/tailwindcss-intellisense)  
Languages: `CSS`  
Categories: `LSP`  

```
:MasonInstall tailwindcss-language-server
```
# taplo

> A versatile, feature-rich TOML toolkit.

Homepage: [https://taplo.tamasfe.dev/](https://taplo.tamasfe.dev/)  
Languages: `TOML`  
Categories: `LSP`  

```
:MasonInstall taplo
```
# teal-language-server

> A language server for Teal, a typed dialect of Lua.

Homepage: [https://github.com/teal-language/teal-language-server](https://github.com/teal-language/teal-language-server)  
Languages: `Teal`  
Categories: `LSP`  

```
:MasonInstall teal-language-server
```
# tectonic

> Tectonic is a modernized, complete, self-contained TeX/LaTeX engine, powered by XeTeX and TeXLive.

Homepage: [https://tectonic-typesetting.github.io](https://tectonic-typesetting.github.io)  
Languages: `LaTeX`  
Categories: `Compiler`  

```
:MasonInstall tectonic
```
# terraform-ls

> Terraform Language Server.

Homepage: [https://github.com/hashicorp/terraform-ls](https://github.com/hashicorp/terraform-ls)  
Languages: `Terraform`  
Categories: `LSP`  

```
:MasonInstall terraform-ls
```
# texlab

> An implementation of the Language Server Protocol for LaTeX.

Homepage: [https://github.com/latex-lsp/texlab](https://github.com/latex-lsp/texlab)  
Languages: `LaTeX`  
Categories: `LSP`  

```
:MasonInstall texlab
```
# textlint

> The pluggable natural language linter for text and markdown.

Homepage: [https://textlint.github.io](https://textlint.github.io)  
Languages: `Text` `Markdown`  
Categories: `Linter`  

```
:MasonInstall textlint
```
# tflint

> A Pluggable Terraform Linter.

Homepage: [https://github.com/terraform-linters/tflint](https://github.com/terraform-linters/tflint)  
Languages: `Terraform`  
Categories: `LSP` `Linter`  

```
:MasonInstall tflint
```
# tree-sitter-cli

> The Tree-sitter CLI allows you to develop, test, and use Tree-sitter grammars from the command line. It works on
MacOS, Linux, and Windows.


Homepage: [https://github.com/tree-sitter/tree-sitter/blob/master/cli/README.md](https://github.com/tree-sitter/tree-sitter/blob/master/cli/README.md)  
Languages:   
Categories: `Compiler`  

```
:MasonInstall tree-sitter-cli
```
# twigcs

> The missing checkstyle for twig! Twigcs aims to be what phpcs is to php. It checks your codebase for violations on
coding standards.


Homepage: [https://github.com/friendsoftwig/twigcs](https://github.com/friendsoftwig/twigcs)  
Languages: `Twig`  
Categories: `Linter`  

```
:MasonInstall twigcs
```
# typescript-language-server

> TypeScript & JavaScript Language Server.

Homepage: [https://github.com/typescript-language-server/typescript-language-server](https://github.com/typescript-language-server/typescript-language-server)  
Languages: `TypeScript` `JavaScript`  
Categories: `LSP`  

```
:MasonInstall typescript-language-server
```
# typst-lsp

> A brand-new language server for Typst.

Homepage: [https://github.com/nvarner/typst-lsp](https://github.com/nvarner/typst-lsp)  
Languages: `Typst`  
Categories: `LSP`  

```
:MasonInstall typst-lsp
```
# unocss-language-server

> Language Server Protocol implementation for UnoCSS.

Homepage: [https://github.com/xna00/unocss-language-server](https://github.com/xna00/unocss-language-server)  
Languages: `CSS`  
Categories: `LSP`  

```
:MasonInstall unocss-language-server
```
# usort

> Safe, minimal import sorting for Python projects.

Homepage: [https://usort.readthedocs.io/](https://usort.readthedocs.io/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall usort
```
# vacuum

> vacuum is the worlds fastest OpenAPI 3, OpenAPI 2 / Swagger linter and quality analysis tool. Built in go, it tears
through API specs faster than you can think. vacuum is compatible with Spectral rulesets and generates compatible
reports.


Homepage: [https://github.com/daveshanley/vacuum](https://github.com/daveshanley/vacuum)  
Languages: `OpenAPI`  
Categories: `Linter`  

```
:MasonInstall vacuum
```
# vala-language-server

> Code Intelligence for Vala & Genie.

Homepage: [https://github.com/vala-lang/vala-language-server](https://github.com/vala-lang/vala-language-server)  
Languages: `Vala`  
Categories: `LSP`  

```
:MasonInstall vala-language-server
```
# vale

> 📝 A syntax-aware linter for prose built with speed and extensibility in mind.

Homepage: [https://vale.sh/](https://vale.sh/)  
Languages: `Text` `Markdown` `LaTeX`  
Categories: `Linter`  

```
:MasonInstall vale
```
# verible

> Verible is a suite of SystemVerilog developer tools, including a parser, style-linter, and formatter.

Homepage: [https://chipsalliance.github.io/verible/](https://chipsalliance.github.io/verible/)  
Languages: `SystemVerilog`  
Categories: `LSP` `Linter` `Formatter`  

```
:MasonInstall verible
```
# veryl-ls

> Veryl language server.

Homepage: [https://github.com/dalance/veryl](https://github.com/dalance/veryl)  
Languages: `Veryl`  
Categories: `LSP`  

```
:MasonInstall veryl-ls
```
# vetur-vls

> VLS (Vue Language Server) is a language server implementation compatible with Language Server Protocol.

Homepage: [https://github.com/vuejs/vetur](https://github.com/vuejs/vetur)  
Languages: `Vue`  
Categories: `LSP`  

```
:MasonInstall vetur-vls
```
# vim-language-server

> VimScript language server.

Homepage: [https://github.com/iamcco/vim-language-server](https://github.com/iamcco/vim-language-server)  
Languages: `VimScript`  
Categories: `LSP`  

```
:MasonInstall vim-language-server
```
# vint

> Fast and Highly Extensible Vim script Language Lint implemented in Python.

Homepage: [https://github.com/Vimjas/vint](https://github.com/Vimjas/vint)  
Languages: `VimScript`  
Categories: `Linter`  

```
:MasonInstall vint
```
# visualforce-language-server

> Visualforce language server.

Homepage: [https://github.com/forcedotcom/salesforcedx-vscode](https://github.com/forcedotcom/salesforcedx-vscode)  
Languages: `Visualforce`  
Categories: `LSP`  

```
:MasonInstall visualforce-language-server
```
# vls

> V language server.

Homepage: [https://github.com/vlang/vls](https://github.com/vlang/vls)  
Languages: `V`  
Categories: `LSP`  

```
:MasonInstall vls
```
# vtsls

> LSP wrapper around the TypeScript extension bundled with VSCode.

Homepage: [https://github.com/yioneko/vtsls](https://github.com/yioneko/vtsls)  
Languages: `JavaScript` `TypeScript`  
Categories: `LSP`  

```
:MasonInstall vtsls
```
# vue-language-server

> ⚡ Explore high-performance tooling for Vue.

Homepage: [https://github.com/johnsoncodehk/volar](https://github.com/johnsoncodehk/volar)  
Languages: `Vue`  
Categories: `LSP`  

```
:MasonInstall vue-language-server
```
# vulture

> Vulture finds unused code in Python programs. This is useful for cleaning up and finding errors in large code bases.
If you run Vulture on both your library and test suite you can find untested code.

Due to Python's dynamic nature, static code analyzers like Vulture are likely to miss some dead code. Also, code that
is only called implicitly may be reported as unused. Nonetheless, Vulture can be a very helpful tool for higher code
quality.


Homepage: [https://github.com/jendrikseipp/vulture](https://github.com/jendrikseipp/vulture)  
Languages: `Python`  
Categories: `Linter`  

```
:MasonInstall vulture
```
# wgsl-analyzer

> A language server implementation for the WGSL shading language.

Homepage: [https://github.com/wgsl-analyzer/wgsl-analyzer](https://github.com/wgsl-analyzer/wgsl-analyzer)  
Languages: `WGSL`  
Categories: `LSP`  

```
:MasonInstall wgsl-analyzer
```
# write-good

> Naive linter for English prose for developers who can't write good and wanna learn to do other stuff good too.


Homepage: [https://github.com/btford/write-good](https://github.com/btford/write-good)  
Languages: `Markdown`  
Categories: `Linter`  

```
:MasonInstall write-good
```
# xmlformatter

> xmlformatter is an Open Source Python package that provides formatting of XML documents. xmlformatter differs from
others formatters by handling whitespaces by a distinct set of formatting rules - formatting element content by an
object style and mixed content by a text style. You may find xmlformatter useful for corrections and presentations.


Homepage: [https://github.com/pamoller/xmlformatter](https://github.com/pamoller/xmlformatter)  
Languages: `XML`  
Categories: `Formatter`  

```
:MasonInstall xmlformatter
```
# xo

> JavaScript/TypeScript linter (ESLint wrapper) with great defaults.

Homepage: [https://github.com/xojs/xo](https://github.com/xojs/xo)  
Languages: `JavaScript` `TypeScript`  
Categories: `Linter`  

```
:MasonInstall xo
```
# yaml-language-server

> Language Server for YAML Files.

Homepage: [https://github.com/redhat-developer/yaml-language-server](https://github.com/redhat-developer/yaml-language-server)  
Languages: `YAML`  
Categories: `LSP`  

```
:MasonInstall yaml-language-server
```
# yamlfmt

> yamlfmt is an extensible command line tool or library to format yaml files.

Homepage: [https://github.com/google/yamlfmt](https://github.com/google/yamlfmt)  
Languages: `YAML`  
Categories: `Formatter`  

```
:MasonInstall yamlfmt
```
# yamllint

> Linter for YAML files. yamllint does not only check for syntax validity, but for weirdnesses like key repetition and
cosmetic problems such as lines length, trailing spaces, indentation, etc.


Homepage: [https://github.com/adrienverge/yamllint](https://github.com/adrienverge/yamllint)  
Languages: `YAML`  
Categories: `Linter`  

```
:MasonInstall yamllint
```
# yapf

> YAPF, Yet Another Python Formatter.

Homepage: [https://pypi.org/project/yapf/](https://pypi.org/project/yapf/)  
Languages: `Python`  
Categories: `Formatter`  

```
:MasonInstall yapf
```
# yls-yara

> Language server for the YARA language.

Homepage: [https://avast.github.io/yls/](https://avast.github.io/yls/)  
Languages: `YARA`  
Categories: `LSP`  

```
:MasonInstall yls-yara
```
# zk

> A plain text note-taking assistant.

Homepage: [https://github.com/mickael-menu/zk](https://github.com/mickael-menu/zk)  
Languages: `Markdown`  
Categories: `LSP`  

```
:MasonInstall zk
```
# zls

> Zig LSP implementation + Zig Language Server.

Homepage: [https://github.com/zigtools/zls](https://github.com/zigtools/zls)  
Languages: `Zig`  
Categories: `LSP`  

```
:MasonInstall zls
```

---
<sub><sup>
[https://github.com/williamboman/mason.nvim](https://github.com/williamboman/mason.nvim)
</sup></sub>