Open-source alternatives to Haskell Language Server

This project is a language extension for VS Code that provides comprehensive Go language support. It functions as a language server client, a debugger interface, and a toolchain manager to facilitate Go application development. The extension distinguishes itself by integrating a full suite of toolchain management capabilities, allowing for the installation and configuration of required binaries, linters, and compiler versions directly within the editor. It also provides deep integration for interactive debugging via Delve, supporting remote target debugging, process attachment, and program st

ktlint is a linter and code formatter for Kotlin that checks source files against a built-in set of style rules and automatically rewrites them to match those rules. It operates by walking the Kotlin abstract syntax tree, detecting violations, and applying transformations directly at the node level before regenerating the source code from the modified tree. The project ships a curated default rule set that requires no configuration to enforce consistent formatting, and provides a command-line interface for running linting and formatting in batch mode. Its rule-set-based plugin architecture al

esbuild is a high-performance JavaScript bundler and transpiler designed to transform modern web assets into production-ready code. Built with a focus on speed, it utilizes a concurrent execution model to perform parsing, linking, and code generation across multiple CPU cores. The engine handles a wide range of tasks, including TypeScript compilation, JSX transformation, and CSS bundling, while maintaining a consistent build process across diverse environments. What distinguishes the project is its architecture, which leverages memory-mapped file processing and a single-pass transformation st

Vue is a progressive, component-based JavaScript framework designed for building reactive user interfaces and single-page applications. It centers on a declarative template system that transforms HTML into efficient render functions, allowing developers to organize complex interfaces into isolated, reusable units that synchronize automatically with application state. The framework distinguishes itself through a dependency-tracking reactivity system that monitors data access during rendering to trigger precise updates. It provides a flexible architecture that supports both incremental adoption

Buck2 is a programmable monorepo build tool and hermetic build system designed to manage large-scale projects with complex target graphs and multi-language dependencies. It functions as a remote execution framework and dependency graph analyzer, providing an artifact caching engine to ensure reproducible and consistent build results across different environments. The system distinguishes itself through an incremental computation engine that recomputes only the specific nodes in a dependency graph invalidated by changes. It utilizes content-addressable storage for build artifact caching and su

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis

TinyMCE is a JavaScript rich text editor and WYSIWYG HTML editor that provides a visual interface for creating and formatting content within web applications. It functions as an extensible editor framework and web content management UI, allowing users to author and style documents through a browser-based interface. The project is distinguished by a plugin-based extension system and a public API that enable the addition of custom capabilities and modifications to the visual interface. It utilizes a framework-agnostic core, providing dedicated integration for React, Vue, and Angular. The syste

Excelize is a library for reading and writing spreadsheet files in the Office Open XML format. It provides a comprehensive suite of tools for programmatically creating, modifying, and analyzing workbooks, worksheets, and cell data, ensuring compatibility across various office software suites through structured XML serialization. The library distinguishes itself with a built-in formula calculation engine that evaluates complex mathematical and logical expressions directly against workbook data. It also features a memory-mapped streaming architecture, which allows for the efficient processing o

kotlin-lsp is a language server implementation that integrates editors with the Kotlin compiler and build tools to provide language intelligence and code analysis. It uses the Language Server Protocol to decouple heavy language processing from the text editor user interface. The project provides static code analysis to detect issues and provide real-time diagnostics. It enables source code navigation through symbol-index based jumping to definitions and an analysis of how components interact. Additional capabilities include automated source code formatting, intelligent code completion, and s

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

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

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

Stack is a build tool, package manager, and project bootstrapper for the Haskell language. It provides a consistent environment for compiling source code, managing project binaries, and executing programs. The system ensures reproducible builds through snapshot-based dependency resolution and manages the installation of specific compiler binaries to match project requirements. It utilizes content-addressable package storage and local-path caching to maintain the integrity of source code and avoid redundant downloads across different projects. The toolset covers the full development lifecycle

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

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

ZLS is a language server for the Zig language that implements the Language Server Protocol to provide IDE-like intelligence. It functions as a code intelligence provider, static code analysis tool, and automated refactoring engine for Zig projects. The server integrates directly with the Zig compiler toolchain to derive precise type information and perform semantic analysis. It uses this integration to surface real-time compilation errors as editor diagnostics and to provide semantic syntax highlighting based on resolved types rather than regex patterns. The project covers a wide range of de

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

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.

RuboCop is a static code analyzer, linter, and formatter for the Ruby language. It detects style violations, potential bugs, and code smells by scanning source code without executing the program. The tool enforces a predefined Ruby style guide by flagging deviations and automatically rewriting source code to ensure consistency across projects. It includes a language server that provides real-time analysis and formatting suggestions directly within text editors.

Symbols-outline.nvim is a Neovim plugin that renders a dedicated sidebar panel displaying a hierarchical tree view of code symbols. It communicates with language servers to extract structural code information, functions, classes, and variables, allowing users to browse and navigate document structures directly from an interactive interface. The plugin tracks active cursor movements in code buffers to automatically highlight corresponding items in the outline panel. Users can interactively collapse or expand nested tree branches, jump directly to selected symbol locations in source files, prev

LazyVim is a modular configuration framework and distribution for Neovim that transforms a base text editor into a comprehensive integrated development environment. It provides a structured system for managing, loading, and orchestrating editor extensions using Lua, designed to standardize professional development workflows through a curated collection of settings and plugins. The project distinguishes itself through a focus on performance and stability, utilizing deferred plugin initialization to minimize startup latency and resource consumption. Its architecture relies on a directory-based

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

Tern is an editor-independent code analyzer and static analysis engine for JavaScript. It functions as a language server that provides semantic intelligence by parsing source code into abstract syntax trees to infer types and resolve symbols without requiring manual type annotations. The engine distinguishes itself through the use of JSON-based type definitions, which allow it to describe library signatures and external dependencies without needing the original source code. It also features a plugin system that enables the extension of server functionality to support custom loaders or framewo

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces

Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions as a transpiler designed to leverage the Go runtime while introducing a type system centered on algebraic data types and result-based error handling. The language distinguishes itself by replacing Go's multiple return values with result and option types, using a dedicated operator for concise error propagation. It implements sum types with exhaustive pattern matching and provides a tool to generate bindings for existing Go packages, automatically converting multi-value returns

Scala is a statically typed programming language and compiler that combines object-oriented and functional programming paradigms. It serves as a cross-platform runtime language capable of targeting the Java Virtual Machine and JavaScript to share logic between backend servers and web frontends. The project provides a functional programming framework with immutable data structures and higher-order functions to build reliable concurrent and distributed applications. It distinguishes itself through deep interoperability with Java and JavaScript ecosystems and the ability to transform code into n