Open-source alternatives to Jedi Vim

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

pycparser is a C99 parser library that converts C source code into an abstract syntax tree consisting of Python objects. It functions as an abstract syntax tree generator, transforming preprocessed C code into a structured hierarchy for programmatic analysis and transformation. The library integrates with a C preprocessor to handle directives before parsing. It also features a stub header parser, which uses minimal mock headers to allow the parsing of C code without requiring a full system C library installation. The project provides tools for static code analysis, C program analysis, and so

pretty-ts-errors is a VSCode extension and TypeScript error formatter that converts complex compiler errors into human-readable, visually formatted messages. It functions as a debugging tool that transforms type-checking failures into an improved developer experience within the editor. The tool distinguishes itself by linking type errors to external technical documentation and translation tools for plain-English explanations. It provides integrated navigation that allows users to jump directly from error messages to the corresponding type definitions in the source code. The extension further

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

This project is a Vim keybinding emulation for Visual Studio Code. It implements modal text editing to separate navigation and content creation through specialized modes, reducing reliance on the mouse. The emulator supports custom IDE workflows by importing standard configuration files and remapping keyboard shortcuts. It integrates with external processes to handle complex commands and reproduces logic from common plugins for surrounding characters, commenting, and rapid motion. The capability surface includes keyboard-driven navigation using text objects, markers, and character sequences.

Terser is a JavaScript minifier and compressor designed to reduce file size through whitespace removal, symbol mangling, and logic optimization for ES6+. It functions as a toolkit for minification, a code mangler for shortening variable and property names, and a dead code eliminator that evaluates constant expressions to remove unreachable logic. The project operates as an AST toolkit that parses JavaScript source into SpiderMonkey AST format for structural analysis. It generates source maps to link compressed production code back to the original source, ensuring that minified bundles remain

Include What You Use is a C++ include optimizer and header dependency analyzer. It identifies unused or missing header includes in source files to reduce project bloat and improve compilation performance. The tool performs static analysis using a Clang-based abstract syntax tree to map symbol usage and track preprocessor effects across different build configurations. It can automatically rewrite source files by inserting or deleting preprocessor directives based on the calculated dependency graph. The system integrates with compilation databases to determine the exact compiler flags used for

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

Jazzy is a source code documentation tool and API generator designed for Swift and Objective-C. It analyzes project roots and compiled modules to produce searchable HTML websites or offline docsets. The system functions as a multi-module API documenter, aggregating documentation from separate source modules into a single site with cross-module linking. It serves as a markdown-based documentation engine that integrates technical guides and LaTeX mathematical equations to complement generated API references. The tool covers a broad capability surface including multi-language API generation for

autopep8 is a Python static code styler and formatter designed to automatically rewrite source code to comply with the PEP 8 style guide. It functions as a recursive code cleaner that identifies and fixes indentation, whitespace, and syntax irregularities across entire projects. The tool performs structural refactoring using abstract syntax tree transformations to execute non-whitespace changes, such as shortening long lines and improving identity tests. It includes an aggressive refactoring mode for complex style violations and supports selective formatting via inline markers to disable chan

The C/C++ extension for Visual Studio Code provides language support for C and C++ programming, including IntelliSense-powered code editing, navigation, and debugging capabilities. It enables syntax highlighting, code completion, hover information, and error checking for C and C++ source files, along with features like semantic colorization, symbol search, and call hierarchy exploration. The extension offers comprehensive debugging support for C/C++ programs, including launching debug sessions with breakpoints, stepping through code, and inspecting variables. It supports debugging multi-threa

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

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

This project is a Vim IDE configuration and plugin suite designed to transform the Vim text editor into a full development environment. It focuses on C++ development by integrating source code indexing and automated plugin management. The environment utilizes compiler backends and abstract syntax trees for semantic code completion and static code analysis. It employs tag files for symbol indexing, enabling rapid navigation between function definitions, class headers, and implementation files. The workspace includes productivity tools such as shorthand snippet expansion, line bookmarking, and

This project is an IDE extension for the IntelliJ Platform that provides language support for Go. It integrates Go development tools into JetBrains IDEs to facilitate writing, organizing, and analyzing source code. The plugin enables the transformation of Go source code into executable binaries by managing build processes and executing the standard compiler. It also includes utilities for configuring the Go software development kit and generating initial application and library files to bootstrap project structures. The toolset provides static code analysis through syntax highlighting and a

This project is a high-performance compiler written in Rust that transpiles TypeScript and ECMAScript into compatible JavaScript code. It functions as a TypeScript transpiler, a JavaScript minifier, and a JavaScript bundler. The system distinguishes itself through a WebAssembly plugin host that allows the execution of custom transformation rules without modifying the core binary. It also provides specialized compilation for React source code to improve runtime performance and reduce execution overhead. The broader capability surface includes source-to-source compilation, type annotation stri

Sweep is an automated software engineering system that uses large language models to resolve GitHub issues. It functions as an AI software engineer that transforms natural language issue descriptions into concrete code changes and pull requests. The system integrates with GitHub webhooks to trigger workflows based on issue creation or label updates. It employs an iterative feedback loop that analyzes compiler errors and test results to refine generated code and correct bugs. The tool covers a range of maintenance capabilities, including automated bug fixing, feature implementation, and codeb

ts-morph is a TypeScript AST manipulation library and a high-level wrapper for the TypeScript compiler API. It provides a programmatic interface for analyzing, modifying, and generating TypeScript source code, serving as a tool for automated code refactoring and source code generation. The library simplifies the process of navigating and inspecting project structures by offering an object-oriented abstraction over the underlying compiler API. It allows for the programmatic transformation of existing codebases to automate structural updates and bulk code migrations. Its capabilities cover sta

Vulture is a static analysis tool and linter designed to find unused variables, functions, and classes in Python source code. It operates as a dead code detector and unused code finder that scans source files to identify unreachable expressions and imports without executing the code. The tool employs a confidence-based heuristic scoring system to assign probability values to detections, helping to distinguish truly unused symbols from potential false positives. It further assists in pruning dead logic by sorting detected unused classes and functions by line count to prioritize the removal of

pyenv-virtualenv is a plugin for pyenv that creates and manages isolated Python virtual environments on Unix-like systems. It functions as an environment orchestrator that extends the core version switching system to provide project isolation. The tool automates the activation and switching of Python environments based on the current working directory. It also includes a bridge for managing and interacting with Conda environments through the pyenv interface. The project covers the full lifecycle of environment management, including the creation, listing, and deletion of isolated environments

Pipx is a system for installing, running, and managing isolated Python applications and their corresponding virtual environments. It functions as an application installer for Python command line tools, a manager for listing and upgrading those tools, and a runner for executing packages in temporary environments. The tool ensures that every installed package resides in its own dedicated virtual environment to prevent dependency conflicts. It automatically adds the binaries of installed applications to the system path and enables the execution of tools within ephemeral environments that are del

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.

gptme is an autonomous AI agent server and framework designed for local system automation, software development, and code execution. It operates as a local execution engine that enables language models to run shell commands, modify local files, and interact with the operating system. The project functions as a Model Context Protocol client, integrating with external servers to expand agent capabilities with standardized tools and data sources. It features a provider-agnostic routing system to orchestrate tasks across multiple proprietary cloud APIs and local AI backends. The system includes

Gophernotes is a backend implementation of the Jupyter kernel protocol and an interactive runtime that enables the execution of Go language code within notebook environments. It serves as a Go language execution engine, allowing users to integrate Go into polyglot notebooks such as Jupyter and nteract. The project supports the creation of documents that combine executable source code with rich media. It maps internal data types to various formats, including HTML, JSON, LaTeX, PDF, and images, to provide visual representations of execution results. The system covers a range of capabilities in

Xi Editor is a high-performance text editor core written in Rust. It employs a decoupled architecture that separates core logic from the presentation layer using a JSON-based client-server protocol. The project features a language-agnostic plugin system that communicates with external extensions via JSON messages over pipes. It manages text buffers using a persistent rope data structure to enable efficient editing of very large files. The system supports asynchronous editor workflows by running expensive operations in background threads using data snapshots. This prevents background processi