Open-source alternatives to Semantic

Universal Ctags is a multi-language symbol indexer and regex-based parsing engine used to extract and catalog functions, classes, and variables from source code. It functions as a source code indexer that scans files across diverse programming languages to create searchable catalogs of definitions and declarations. The project is distinguished by its extensible parser framework, which allows users to define new language rules using regular expressions and configuration files. It supports complex parsing scenarios through state-based parsing, stack-oriented scope tracking, and guest-parser del

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

Tinymist is a comprehensive suite of tools for Typst document authoring, serving as a language server, document compiler, and project manager. It provides a standardized language service via the Language Server Protocol to enable editor features such as autocompletion, navigation, and semantic highlighting. The project distinguishes itself by integrating a TCP-based live preview server for real-time visual rendering and an advanced static analysis tool that utilizes abstract syntax trees and bidirectional type checking. It also includes a project management system capable of handling multi-fi

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

lua-language-server is a static analysis tool and type checker for the Lua language that implements the Language Server Protocol. It provides a system for detecting type mismatches, unused code, and logic errors in source files. The project features an inference-based type system that deduces variable types and supports optional annotations and meta files to enforce type safety. It allows for the definition of custom types and function signatures, including support for overloads and member visibility controls. The server provides a broad set of IDE capabilities, including real-time code auto

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

This repository contains a collection of extensions and configurations for a text editor plugin ecosystem. It provides a framework for adding language support and custom behavior through a system of customizable key bindings, a project indexing engine, and a syntax highlighting framework. The project utilizes a Python API to enable the development of custom plugins, menus, and tools. It supports a functional extension framework where users can create custom themes, syntax definitions, and resource overrides to expand the editor's visual styles and capabilities. The system covers advanced tex

ApplicationInspector is a multi-language static analysis tool designed to detect specific features and characteristics within source code. It utilizes a declarative JSON rules engine to identify patterns and structural tags across project directories without requiring the analyzer to be recompiled. The system distinguishes itself through a code version differ that compares two different source paths to report changes in detected features. It also provides utilities for creating and validating custom JSON-based rules, including a validation pipeline to verify syntax and identifier uniqueness.

Ibis is a portable Python dataframe library and multi-backend query engine that provides a unified interface for executing data transformations across diverse compute engines. It functions as a Python SQL expression compiler and dialect transpiler, allowing users to define data logic once and execute it across cloud warehouses, embedded databases, and distributed clusters without rewriting code. The project distinguishes itself through a database backend abstraction that decouples transformation logic from the underlying execution engine. It enables polyglot data workflows by mixing raw SQL s

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

Lark is a Python parsing toolkit used to define grammars and convert raw text into annotated parse trees. It serves as an abstract syntax tree generator and a grammar definition language for specifying language rules through terminals and regular expressions. The library provides two primary parsing implementations: an Earley parsing library capable of handling all context-free languages, including those with ambiguity and left-recursion, and a high-performance LALR parsing library designed for deterministic languages with low memory overhead. Beyond core parsing, the toolkit includes capabi

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

monaco-react is a React component wrapper for the Monaco Editor, providing a declarative way to embed a browser-based text editor into web applications. It includes components for standard code editing with syntax highlighting and a specialized diff editor for side-by-side version comparison. The project enables the integration of syntax validation to flag errors and provides mechanisms for managing multiple files through unique model identifiers, which preserve undo history and selection states during switches. It allows for custom asset loading via CDN or local paths and provides access to

phpDocumentor is a PHP API documentation generator and source code analyzer that transforms PHP files and DocBlocks into structured HTML API references. It functions as a static site generator and an automatic documentation tool designed to synchronize technical documentation with code changes. The project distinguishes itself by acting as a UML diagram generator, producing class and architectural graphs via PlantUML based on source analysis. It also supports technical manual authoring, rendering hand-written guides in Markdown and ReStructuredText alongside the automatically generated API re

This project is a unified toolchain for JavaScript and TypeScript development, providing a suite of specialized tools for bundling, parsing, linting, and formatting source code. The toolchain is implemented in Rust and utilizes a shared internal representation to allow multiple tools to operate on the same parsed source code. It employs a parallelized analysis pipeline and single-pass parsing with error recovery to process files across CPU cores. The suite covers several core capability areas, including static analysis for identifying programmatic errors, automated style standardization, and

This project is a cross-language quantitative trading framework designed to implement and execute trading strategies consistently across Python, JavaScript, C++, and PineScript. It functions as a polyglot trading strategy translator and a multi-language algorithmic trading engine that maps high-level scripting and block-based logic to executable binaries. The system features a financial domain-specific language parser that translates specialized trading syntax and visual programming blocks into a standardized internal representation. It includes a technical analysis pattern library providing

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

CodeMirror 5 is a browser-based code editor and extensible UI component. It functions as a syntax highlighting engine and a programmable text surface, providing a professional coding experience embedded within web pages. The project is distinguished by its ability to act as a collaborative text editor, synchronizing document changes across multiple users in real time. It also includes a dedicated Vim emulation layer that implements modal keyboard interactions, motions, and operators. The system covers broad capability areas including language support for autocompletion and error analysis, co

This project is a compiler development tutorial that provides a series of guides and exercises for building a complete compiler from scratch. It focuses on the implementation of a structured compilation pipeline to transform high-level source code into executable machine instructions. The project covers the creation of a machine code generator for specific processor architectures and a static analysis framework. This framework includes methodologies for implementing type checking and constant folding to verify logic correctness before the final execution phase. The instructional material enc

This project is a collection of educational resources and reference materials designed to provide guidance on version control workflows. It serves as a knowledge base and command reference guide for managing repositories, featuring a categorized cheat sheet and tutorials on optimizing project management. The resources focus on advanced techniques for history manipulation, such as commit recovery, remote synchronization, and repository optimization. It provides practical tips for refining project history through branching, stashing, and the use of configuration settings to speed up common task

This project is a collection of official toolsets and server implementations designed for the parsing, formatting, and semantic analysis of the Go programming language. It includes a language server that provides real-time code intelligence and automated editing capabilities to editors via the Language Server Protocol. The toolset provides a suite of utilities for source code formatting and static analysis. This includes automated standardization of code layout, import organization, and the generation of string representation methods for enumerated types. The project covers broad static anal

HCL is a configuration language implementation designed for parsing, evaluating, and encoding structured settings through the use of blocks and attributes. It functions as a configuration AST parser and a schema-based decoder that maps attributes and blocks to internal data structures using predefined rules. The project includes an expression evaluation engine that resolves dynamic values and cross-references through multi-phase processing of variables and functions. It also provides a configuration file formatter to standardize the layout and indentation of source code for consistent visual

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

Esprima is a JavaScript parser that converts source code into a structured abstract syntax tree. It implements a specification-driven grammar to ensure compliance with ECMAScript standards, enabling the programmatic analysis and transformation of JavaScript programs. The project provides capabilities for lexical tokenization to break source code into individual symbols and static syntax validation to verify that scripts are well-formed without executing the code. Its functional surface covers JavaScript static analysis, lexical analysis, and the generation of abstract syntax trees.

Markdig is a high-performance Markdown processor for .NET applications that converts Markdown text into HTML or other target formats. It is a CommonMark compliant parser and extensible engine that can transform Markdown into a searchable and manipulatable abstract syntax tree. The library provides a framework for adding custom syntax and rendering logic through a modular pipeline of parsers and renderers. It supports native ahead-of-time compilation and trimming to minimize binary size. Capabilities include the generation of structured HTML with custom attributes and styling, the extraction

This project is an agentic development framework and autonomous software engineering system. It utilizes a coordinated network of specialized LLM agents to automate the full software development lifecycle, from codebase exploration and architectural planning to implementation and automated refactoring. The system is distinguished by an agentic memory system and a test-driven development orchestrator. It maintains project continuity across sessions by capturing architectural learnings and state in a persistent semantic database and enforces code quality through an automated cycle of generating

RLS is a language server that provides language intelligence for the Rust programming language. It implements the Language Server Protocol to enable a standardized communication layer between the Rust compiler and various editor clients. The project focuses on providing real-time code completions, symbol navigation, and type information. It also supports automated structural changes, such as workspace-wide symbol renaming, to maintain semantic correctness during refactoring. The system incorporates static code analysis for linting and formatting, alongside a mechanism for incremental compila