Projects sharing features with Mason Lspconfig.nvim

This project is an IntelliJ IDE plugin that provides an integrated development environment for Rust. It serves as a build system orchestrator and debugger interface, offering comprehensive language analysis, syntax highlighting, and intelligent code editing assistance. The plugin integrates with a language server to provide real-time type inference and code navigation. It includes a dedicated static analysis tool for detecting code duplicates, analyzing memory leaks, and measuring test coverage. The toolset covers toolchain management and Cargo integration for dependency and manifest handlin

Ale is a Neovim LSP client and asynchronous linter wrapper designed to integrate language servers and syntax checkers into the editor. It provides infrastructure for background syntax validation and automated code fixing without blocking the editor interface. The project implements the Language Server Protocol to enable advanced semantic navigation, including symbol renaming, definition jumping, and the application of automatic refactoring changes. It functions as an automatic code fixer that applies formatting and repairs based on feedback from linting tools and language servers. The plugin

mini.nvim is a comprehensive library of independent modules designed to extend Neovim with a wide array of navigation, user interface, and text manipulation tools. It serves as a modular plugin collection, a UI toolkit for creating custom statuslines and notifications, and a package manager for installing and pinning external plugins from Git. The project provides a specialized fuzzy picker framework for filtering files and symbols, an LSP completion engine with interactive snippet expansion, and a dedicated plugin test framework that uses headless editor instances and remote procedure calls

Prelude is an Emacs distribution and configuration framework that provides a curated set of defaults and a modular architecture. It functions as a package management wrapper to install and pin stable versions of external extensions, ensuring a consistent and reproducible development environment. The project is distinguished by its modular configuration system, which allows users to customize editor capabilities by toggling specific feature modules via a central configuration file. It also includes an automated language server environment that installs and configures language-specific tools an

fzf-lua is a fuzzy finder integration for Neovim that utilizes fzf to search files, buffers, and project symbols. It serves as a code navigation framework providing a dynamic result generator that populates search windows using real-time shell commands or custom Lua functions. The project distinguishes itself through specialized integration tools for Git and Language Server Protocols. It includes a Git search interface for navigating commits, branches, stashes, and diffs, alongside an LSP integration tool that bridges language server providers to locate definitions and references across a cod

coq_nvim is an asynchronous code completion engine for Neovim. It aggregates suggestions from multiple sources, including language servers, tag files, and local buffers, to provide non-blocking code completion. The engine distinguishes itself through a typo-resistant fuzzy completion filter and a two-stage weighted ranking system that prioritizes candidates based on recency and proximity. It utilizes an embedded SQLite database for local caching and background symbol indexing to accelerate lookups without freezing the editor interface. The project also includes a system for defining and expa

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

Swift Evolution serves as the central governance and design platform for the Swift programming language. It provides a structured, collaborative framework for tracking, discussing, and managing the formal proposals and technical goals that define the language's syntax, semantics, and core features. By maintaining a comprehensive collection of design documentation, the project ensures the long-term stability and consistency of the language as it matures. The repository acts as the primary hub for the language's evolution, coordinating community feedback and technical decisions through a transp

Vim-lsp-settings is a Vim plugin that automates the installation, configuration, and lifecycle management of external language server binaries. It functions as a development environment manager, bridging the gap between the text editor and language-specific analysis tools to provide code intelligence features such as autocompletion and error checking. The plugin distinguishes itself by orchestrating the entire toolchain, including the automated downloading and versioning of language server executables. It employs project-root heuristic detection to identify workspace boundaries, ensuring that

The Kotlin Language Server is a static code analysis tool that provides real-time intelligence for Kotlin projects. By implementing the Language Server Protocol, it enables developers to access professional-grade development features, such as code completion, diagnostics, and navigation, within any compatible text editor. The project distinguishes itself through an architecture that maintains persistent, in-memory compiler instances to facilitate rapid, incremental recompilation during active development. It supports remote hosting via TCP, allowing editors to connect to centralized analysis

Oni2 is a high-performance, extensible text editor and project-based file manager. It functions as a modal code editor, utilizing a keyboard grammar of verbs and motions to navigate and modify source code without a mouse. It also serves as an LSP client, integrating Language Server Protocol servers to provide code completion, symbol navigation, and refactoring. The editor distinguishes itself by acting as a VSCode extension host, allowing it to load and execute language servers and debuggers from the VSCode ecosystem. It provides a programmable environment where custom functionality is implem

This project is a suite of specialized tools for the implementation of a language server, template parsing, and static type validation of single-file components. It provides a language server and a type checker to deliver consistent intelligence and validation for Vue components across different editors and command-line environments. The tooling utilizes a template parser to transform single-file component structures into virtual code, enabling static analysis and type checking on HTML-like structures. This process allows for the extraction of component metadata regarding props, events, and s

This project is a Language Server Protocol implementation for PostgreSQL that provides autocompletion, syntax diagnostics, and type checking for SQL and PL/pgSQL. It functions as a database schema validator and a static analysis engine designed to detect security vulnerabilities, performance bottlenecks, and dangerous migration patterns in database scripts. The server differentiates itself by using live database connections to provide schema-aware intelligence, allowing it to verify that tables, columns, and data types actually exist. It performs static analysis on procedural functions to det

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

AstroNvim is a modular Neovim distribution that functions as a comprehensive development environment. It provides a pre-configured framework for managing editor settings, plugin ecosystems, and language server integrations, effectively transforming a base text editor into a full-featured integrated development environment. The project distinguishes itself through a highly customizable Lua-based architecture that emphasizes modularity and performance. It enables users to manage complex editor configurations through a centralized, declarative system that supports lazy loading, community-maintai

Awesome Emacs is a curated directory of community-driven resources, packages, and configurations designed to extend the functionality of the Emacs text editor. It serves as a comprehensive index for users seeking to transform their editor into a specialized development environment or a highly personalized productivity workspace. The collection highlights tools that enable deep customization of the Emacs experience, ranging from ergonomic key binding schemes and visual interface themes to advanced window management and navigation utilities. It provides a centralized reference for discovering e

This project is a static analysis runner designed to identify bugs, performance bottlenecks, and stylistic inconsistencies within Go codebases. It functions as a comprehensive quality assurance suite that executes multiple analysis tools concurrently to provide a unified diagnostic report. By parsing source code into a structured representation, the tool enforces coding standards, validates import structures, and ensures consistent formatting across entire projects. The tool distinguishes itself through its ability to automate the remediation of identified issues, applying programmatic fixes

Lapce is a high-performance text editor built with Rust that utilizes hardware acceleration for fast rendering and responsiveness. It functions as a modal text editor with Vim-style keybindings to minimize hand movement, an LSP client for language intelligence, and a remote development environment for editing files and executing code on distant servers. The editor features an extensible architecture based on the WebAssembly System Interface, allowing it to execute plugins compiled to WASI for cross-language functionality. It further distinguishes itself by implementing the Debug Adapter Proto

Asyncomplete.vim is an asynchronous autocompletion plugin written in pure Vim script for Vim and Neovim environments. It provides non-blocking suggestion displays in a popup menu without freezing the editor interface, utilizing deferred input buffering and event-driven job dispatching to maintain responsiveness during rapid typing sessions. The plugin integrates external completion sources and language server protocols to supply context-aware code suggestions, definitions, and documentation previews. Its modular provider abstraction collects unified suggestion lists from third-party scripts

SourceCodeSyntaxHighlight is a syntax highlighting engine and version control visualizer. It functions as a source code syntax highlighter that applies color schemes and formatting to programming languages for visual display, and as a tool for highlighting code changes and diffs relative to version control commits. The project is implemented as a macOS Quick Look extension that provides syntax-highlighted previews of source code files within the Finder. It also includes a Language Server Protocol client to provide semantic tokens and hover information during code previews, and a command line

CodeMirror is a browser-based code editor framework and modular extension system used to embed full-featured text editors into web pages. It functions as a syntax tree parsing engine and a language server protocol client, enabling structural language analysis and deep integration with external programming language services. The project is distinguished by its modular architecture, which uses a system of extensions and compartments for dynamic reconfiguration at runtime. It supports real-time collaborative editing and state synchronization through an operational transformation framework, allow

gocode is a language server backend and autocompletion daemon for the Go language. It functions as a static code analyzer and symbol indexer that provides real-time identifier and symbol suggestions to text editors. The project utilizes a client-server daemon architecture to maintain a persistent background process, avoiding the overhead of reloading package metadata for every request. It employs a two-tier metadata caching system and parses compiled package binaries to enable fast symbol lookups and declaration retrieval. The system covers broad capability areas including context-sensitive

This project is a comprehensive Neovim configuration framework and integrated development environment built with a modular Lua-based setup. It provides a cohesive workspace that orchestrates editor aesthetics, keybindings, and plugin lifecycles to transform the editor into a full-featured development environment. The configuration is designed as a polyglot development environment with dedicated support for Python, C++, Lua, Markdown, and LaTeX. It features a specialized LSP client configuration for multi-language code intelligence and a Git integration suite for managing version control workf

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

Deoplete.nvim is an asynchronous completion engine and framework for Neovim and Vim8. It functions as a non-blocking system for fetching and displaying text suggestions, serving as a modular extension that integrates multiple external completion sources without freezing the editor user interface. The project operates as a Language Server Protocol client, bridging the editor to external language servers to provide context-aware, type-safe completions. It further distinguishes itself by supporting intelligent text prediction through the integration of machine learning engines and language-speci

Linutil is a Rust-based system configuration toolbox designed to automate software installation, hardware setup, and security baseline enforcement across various Linux distributions. It functions as a high-performance utility for executing batch configuration jobs and managing system baselines through a terminal interface. The project provides a distribution-agnostic setup manager that allows users to configure hardware peripherals and install desktop environments across different Linux versions. It includes a specialized firewall configuration tool for applying standardized network traffic r

oh-my-pi is an agentic workflow automation platform and AI coding agent orchestrator designed for autonomous software engineering. It functions as a multi-model LLM router and an LSP-integrated development environment, coordinating specialized AI agents to perform codebase analysis, automated refactoring, and complex task execution. The system distinguishes itself through the use of subagent coordination to execute parallel tasks within isolated environments and an auto-research framework for iterative experiments. It employs AST-driven structural search for code discovery and content-hash an