Open-source alternatives to Rls

lsp-mode is a Language Server Protocol client and IDE feature set for Emacs. It functions as a semantic code analysis tool and JSON-RPC communication layer that connects the editor to external language servers to provide intelligent code completion and real-time diagnostics. The project also serves as a Debug Adapter Protocol client, enabling interactive debugging sessions and breakpoint management. This allows for stepping through code and inspecting variables via a standardized protocol, including support for debugging within Docker containers. The system covers a broad range of developmen

Rust-analyzer is a language server implementation that provides real-time code intelligence, static analysis, and development productivity tools for the Rust programming language. It functions as a backend engine that communicates with text editors to deliver deep structural understanding of source code, enabling features like semantic analysis, symbol navigation, and automated refactoring. The project distinguishes itself through a core engine designed for high-performance responsiveness, utilizing incremental query-based compilation and lazy demand-driven evaluation to minimize resource con

SublimeCodeIntel is a code intelligence plugin for the Sublime Text editor that provides symbol-based navigation, autocomplete, and function tooltips. It functions as an IDE feature extension and static code analysis engine, using a cross-language symbol indexer to track definitions across multiple files. The system implements static analysis tooling to map definitions and references without executing program code. This enables users to jump to symbol definitions across an entire project and receive real-time suggestions for modules and symbols while typing. The toolset covers broad capabili

vim-lsp is a Vim plugin that implements the Language Server Protocol to provide an asynchronous code intelligence tool for the editor. It serves as a bridge between Vim and external language servers, providing semantic code analysis and IDE-like navigation and diagnostics. The project provides a refactoring interface for renaming symbols across a workspace and applying quick-fixes. It also enables semantic highlighting, which color-codes elements based on their meaning as determined by the language server. The plugin covers a broad surface of capabilities, including symbol navigation and dis

Pyrefly is a static type checker for Python that operates as a language server, delivering real-time diagnostics, completions, and navigation in any editor supporting the Language Server Protocol. It also performs static tensor shape analysis, using symbolic dimension variables and arithmetic to verify shape consistency in deep learning models without runtime execution. Beyond core type checking, Pyrefly supports gradual adoption workflows: it can generate a baseline of known errors so only new issues are reported, migrate configuration from other type checkers, and automatically suppress exi

coc.nvim is a Node.js extension host and Language Server Protocol client that transforms Vim and Neovim into a full integrated development environment. It provides a framework for executing JavaScript and TypeScript plugins within a separate process to enable advanced IDE features without blocking the editor's main thread. The project is distinguished by its ability to host extensions and language servers through a centralized JSON configuration. It supports the installation and lifecycle management of third-party extensions from registries or local files, allowing users to customize language

This project is a comprehensive, curated directory of static analysis, linting, and security scanning utilities. It serves as a central resource for developers to discover, compare, and select tools based on specific programming languages, licensing models, and integration requirements. The directory distinguishes itself by providing deep metadata for each listed utility, including community-driven popularity rankings, maintenance status, and deployment methods. By aggregating these tools into a single searchable index, it enables teams to identify solutions for enforcing coding standards, ma

sourcekit-lsp is a language server protocol implementation and IDE code intelligence backend. It functions as a Swift language server and source code indexer, providing semantic analysis, autocomplete, and navigation features to compatible text editors. The project integrates directly with the Swift toolchain and SourceKit framework to deliver precise type information. It also leverages Clang-integrated parsing to provide semantic analysis for C-family languages, enabling cross-language navigation across project files. The server manages source code indexing and symbol lookups while using a

This is a Visual Studio Code extension that provides framework-specific IntelliSense for Laravel projects. It acts as a project metadata provider, scanning PHP files and extracting application state to offer intelligent autocomplete for routes, views, configuration keys, and model attributes. The tool includes a specialized suggestion engine for Blade templates, providing autocomplete for directives, sections, and stacks. It supports containerized development by routing commands through virtual environments or custom paths to ensure metadata is accurately extracted from isolated project direc

GraphiQL is an interactive browser-based integrated development environment for writing, testing, and documenting GraphQL queries and mutations. It functions as a code editor, an API exploration tool, and a schema explorer, providing a visual interface for browsing GraphQL types and fields. The project provides a language server that delivers schema-driven autocompletion, linting, and validation via the Language Server Protocol. It allows for the embedding of high-performance editors into external projects and supports the injection of custom tools and components through a sidebar plugin API.

Rector is an automated PHP refactoring and modernization tool designed to upgrade language versions and modernize syntax using predefined rules. It functions as a static analysis engine that inspects code structures and types to identify refactoring targets without executing the code. The project provides a framework for defining custom transformation logic to automate project-specific changes. It distinguishes itself by offering specialized capabilities for migrating legacy or custom frameworks to modern alternatives and converting docblock annotations into native language attributes. The s

Mago is a PHP static analysis tool, linter, and code formatter. It detects type errors, dead code, and logic bugs through advanced type inference and flow analysis, while providing a deterministic engine to rewrite source files according to style guides. The project distinguishes itself with a WebAssembly runtime that enables PHP analysis to execute entirely within a web browser, allowing results to be shared via URL. It also provides a minimal Dockerized toolchain distributed as a scratch image for consistent execution across different processor architectures. The toolset covers architectur

Flow is a JavaScript static type checker and AST parser that identifies type errors and prevents runtime failures through static annotations. It functions as a code intelligence engine and a static analysis linter to identify unsafe coding patterns and enforce consistency across a codebase. The project includes a type annotation stripper that removes static type signatures from source code, ensuring the resulting JavaScript is compatible with any runtime environment. It also provides a parser that converts typed JavaScript into an abstract syntax tree conforming to the ESTree specification.

Ale is an asynchronous code analysis tool and integrated development environment plugin designed for lightweight text editors. It functions as a language server protocol client, enabling real-time code intelligence and diagnostic feedback by running analysis tasks in the background to ensure the editor interface remains responsive during intensive operations. The plugin utilizes an event-driven architecture to monitor text buffers and trigger linting or formatting routines automatically. It distinguishes itself through a modular extensibility framework that supports a wide range of language-s

Moon is a monorepo build system and task runner designed to orchestrate complex projects with multiple packages. It functions as a dependency graph orchestrator that executes build targets in topological order and utilizes input hashing to cache results and skip redundant work. The project features a polyglot toolchain manager that automates the installation and versioning of language runtimes and CLI tools to ensure environment consistency. It also includes a plugin framework based on WebAssembly, allowing developers to extend build logic and toolchain behavior using any supported language.

OpenRewrite is an automated refactoring engine and source-to-source migration framework. It uses a lossless semantic tree parser to represent source code as type-aware trees that preserve original whitespace and formatting, enabling precise and deterministic modifications. The project utilizes a declarative refactoring pipeline where sequences of transformations are defined in YAML to resolve breaking changes and technical debt. It features type-aware pattern matching and cross-language model mapping to apply similar refactoring patterns across different programming languages. The framework

This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments. The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checkin

YouCompleteMe is a completion engine and semantic code analyzer for the Vim editor. It provides an integrated suite of development tools, including a Language Server Protocol client and a semantic analyzer that utilizes Clang to offer context-aware symbols and type-based highlighting. The project distinguishes itself through specialized semantic completion for C-family languages and JavaScript, offering identifiers, snippets, and automatic imports. It provides advanced visual feedback such as inlay hints for type information and parameter names, as well as semantic highlighting based on the a

Marksman is a Language Server Protocol implementation for Markdown that provides advanced editor features including autocomplete, go-to-definition, and hover support for markdown files. It serves as an analysis engine to manage documentation and knowledge bases through automated link validation and consistent cross-referencing across multiple documents. The project enables the navigation of complex networks of wiki-style links and headings. It supports content refactoring, allowing users to rename headings and update internal references across multiple files to maintain document integrity dur

Phan is a static analyzer and type checker for PHP that identifies bugs and type incompatibilities without executing the code. It serves as a quality gate for continuous integration pipelines and a tool for verifying type safety, specifically checking union types, generics, and array shapes. The project is distinguished by its use of a background daemon and Language Server Protocol implementation, which provide real-time diagnostics and navigation within editors. It also features a baseline-based suppression system that allows developers to record existing errors in a snapshot file to focus e

This repository contains a collection of code examples that demonstrate how to build extensions for Visual Studio Code using its extension API. The samples cover the core patterns for extending the editor, including implementing code actions, completions, snippets, and semantic token highlighting. The examples show how to integrate a language server to provide diagnostics, completions, and hover information, as well as how to register a source control provider with file status and commit operations. Custom task types that run shell commands or scripts are also demonstrated, along with virtual

Zed is a terminal-based code editor built in Rust that provides a full-featured editing experience with familiar keybindings, mouse support, and multiple cursors. It runs entirely in the terminal while offering capabilities typically found in graphical editors, including split panes, a command palette, and integrated language server protocol support for real-time diagnostics, completions, go-to-definition, and code actions across multiple languages. The editor distinguishes itself through a plugin system that runs sandboxed TypeScript plugins in a QuickJS runtime, with an asynchronous bridge

dprint is a multi-language code formatter that applies consistent styling across various programming languages using a pluggable architecture. It functions as a unified project style management tool, a command-line interface for continuous integration style enforcement, and a Language Server Protocol implementation for real-time formatting in editors. The project is distinguished by a WebAssembly-based plugin system that loads sandboxed formatting logic from URLs or file paths. It further extends its capabilities through a process-based tool integration that wraps external command-line interf

TFLint is a static analysis tool and infrastructure-as-code validator designed to identify errors and enforce best practices within Terraform configuration files. It functions as a quality gate for automated workflows and a language server that provides real-time diagnostics and linting errors directly within supported text editors. The project utilizes a gRPC plugin framework that allows for the integration of custom provider-specific validation rules via independent binaries and a dedicated SDK. This architecture separates core linting logic from cloud-specific validation, supporting the au

This project is a Vim configuration distribution and IDE framework designed to transform Vim into a full-featured development environment. It functions as an environment bootstrapper that automates the cloning and installation of editor configurations and plugin bundles to ensure a consistent setup across different machines. The distribution uses a structured layer of settings and overrides, allowing users to customize the environment via local and fork-specific files without modifying the base source. It provides a curated collection of extensions that enable IDE-like capabilities for code n

TabNine is an AI-powered code completion engine that runs a deep-learning model to generate real-time code suggestions across all programming languages. It operates as an editor plugin that communicates with a backend through a JSON message-passing interface, processing code entirely on the local machine or within a private cloud to keep source code secure and private. The system provides a completion request API that accepts cursor context and returns ranked text completions, with features for configuring completion regions, prefetching files for indexing, and managing binary versions and up