TeXiFy-IDEA is an IntelliJ IDEA plugin that provides comprehensive LaTeX editing support. It enhances the IntelliJ Platform with features including syntax highlighting, code completion, inspections, refactoring intentions, build execution (supporting pdfLaTeX, XeLaTeX, LuaLaTeX, latexmk, biber), forward/inverse search with PDF viewers, bibliography management (local BibTeX and remote libraries like Zotero/Mendeley), and project structure visualization. The plugin follows IntelliJ Platform SDK conventions with a modular architecture organized around concerns like actions, editing, grammar, indexing, PSI, run configurations, settings, structure view, utilities, and remote library integration. It demonstrates strong software engineering practices through patterns like step-based execution systems, PDF viewer abstraction, magic comment parsing, Kotlin DSL builders for command definitions, and generic caching mechanisms. The plugin is actively maintained with recent commits, regular version updates, dependency management via Dependabot, and comprehensive testing.
Serena is a production-grade MCP (Model Context Protocol) server that provides AI coding agents with deep code intelligence across 40+ programming languages. It acts as an 'IDE for your agent', offering symbol-level retrieval, editing, refactoring, and debugging capabilities by orchestrating Language Server Protocol (LSP) backends. The system is designed to integrate with AI clients like Claude Code, Codex, Copilot, and Grok, exposing a rich set of tools for file manipulation, symbol navigation, memory persistence, and project configuration. Architecturally, Serena is a Python application with a CLI entry point that starts an MCP server, a Flask-based web dashboard for monitoring and configuration, and a hooks system for client-side pre-tool-use events. Its core is the `solidlsp` package, a custom synchronous LSP abstraction layer that manages the lifecycle of 40+ language servers (Python, TypeScript, Rust, Go, Java, etc.), handling initialization, capability negotiation, and request/response framing. The `interprompt` library provides a sandboxed Jinja templating engine for prompt generation, and the memory manager persists project-specific context across sessions. Key features include: multi-language symbol search, references, definitions, hover, rename, and diagnostics; a code editor abstraction supporting both LSP and JetBrains backends; a configurable tool registry with automatic discovery; and a comprehensive test suite with per-language integration tests. The project emphasizes reproducibility through pinned dependency versions and SHA256 verification for downloaded language server binaries, though this creates a maintenance burden as versions must be manually updated.
This repository is an IntelliJ Platform plugin that integrates ktlint, the Kotlin linter, into JetBrains IDEs. It runs ktlint automatically on Kotlin files, highlights violations in the editor, provides quick fixes, and supports custom rulesets and baseline files. The plugin is built as a Gradle multi-module project with a dedicated ktlint-lib module that bundles the ktlint engine, and a ktlint-plugin module containing the IntelliJ-specific integration. It uses the IntelliJ Platform Gradle Plugin, convention plugins in build-logic, and a set of shell scripts for release and IDE compatibility checks. Architecturally, the plugin is a standard IntelliJ plugin: it registers an external annotator for real-time diagnostics, a local inspection for batch analysis, and persistent settings components for application and project configuration. It caches baseline violations to avoid re-reporting known issues and loads external ruleset JARs at runtime. The build is automated with GitHub Actions for build verification, UI tests, IDE release checks, and Gradle wrapper updates. The code is written in Kotlin and follows IntelliJ plugin best practices, with JUnit4 tests and a release pipeline that generates plugin descriptions from the README.
This is an IntelliJ IDEA plugin providing comprehensive Elixir language support. It implements a full IDE integration: lexer/parser for Elixir, BEAM bytecode decompiler, debugger with line breakpoints and variable inspection, EEx/HEEx template support, code insight (completion, navigation, refactoring, inspections), SDK management for Elixir/Erlang, and integration with external tools (Credo, Dialyzer, mix format). The architecture is a monolith within the IntelliJ Platform, with generated PSI from Grammar-Kit and hand-written Kotlin/Java modules for resolvers, annotators, formatting, and debugger backend. The codebase demonstrates strong engineering practices: read-lock discipline, coroutine-based concurrency, modular operator interfaces, and systematic test coverage (parser definition tests, variable oracle tests, formatting tests). It is actively maintained with frequent releases tracking IntelliJ Platform API changes. The repository is not a data or research project; it is a production-quality IDE plugin.
This repository is the open-source 'Rainbow Brackets Lite' IntelliJ IDEA plugin, a free and feature-limited version of the popular Rainbow Brackets plugin. The plugin colorizes nested brackets (round, square, squiggly, angle) with distinct colors to improve code readability, and provides additional features like rainbow indent guide lines and scope highlighting via mouse shortcuts. It is implemented as a JetBrains plugin using the IntelliJ Platform SDK, with core logic split between an Annotator (for simple leaf-elements) and a HighlightVisitor (for more accurate per-language matching via BracePairProvider extension points). The architecture follows standard IntelliJ plugin patterns: extension points for brace providers, custom text attributes, and a thorough settings UI integrated into the IDE's color scheme page. The codebase is well-structured with proper separation of concerns, utility functions (memoization, color blending), and comprehensive tests for multiple languages. While tightly coupled to the IntelliJ API, several components (BracePairProvider interface, memoization utility, color blending) demonstrate non-obvious skill and could be extracted for reuse in other JetBrains plugins or JVM projects.
This repository is the JetBrains Godot Support plugin, a multi-language IDE extension for IntelliJ IDEA and Rider that provides comprehensive GDScript language intelligence, scene editing, debugging, and project integration for the Godot game engine. It consists of several modules: a Kotlin-based GDScript language plugin with custom lexer/parser, PSI, annotations, inspections, refactoring, formatting, code completion, and LSP client; a C# debugger worker that allows inspecting Godot scenes during debugging with optimized bulk-fetch strategies; a C++ native addon (GDExtension) for bidirectional communication between the IDE and Godot editor; a PHP toolchain to generate SDK metadata from Godot's official XML documentation; and .NET ReSharper components for C# Godot project support. The plugin uses JetBrains' PolySymbols framework for unified symbol resolution and has an extensive test suite covering parsing, type inference, inspections, and debugger integration. While deeply integrated with JetBrains platform APIs and generated code, the debugger worker's child-chunking algorithm and SDK fingerprinting utility are well-crafted, self-contained components that could be reused in other contexts. The codebase is actively maintained with regular commits, but relies on several internal/experimental APIs and snapshot dependencies, posing moderate technical drift risk.
Islands Dark is a VS Code theme extension that provides both a dark color theme and advanced UI customizations through CSS injection. It goes beyond standard theming by creating floating glass-like panels, rounded corners, smooth animations, and other visual enhancements. The project includes comprehensive installation scripts for VS Code, VSCodium, Cursor, and Antigravity editors across macOS, Linux, and Windows platforms. While the installation logic is somewhat boilerplate, the animations.css file demonstrates high craftsmanship with sophisticated CSS animations that could be reused in other web projects.
ProxyAI (formerly CodeGPT) is a JetBrains IDE plugin that provides AI-powered code assistance including chat, inline editing, code completions, agent-based task execution, commit message generation, and next-edit suggestions. The plugin integrates with multiple LLM providers (OpenAI, Anthropic, Google, Mistral, Ollama, llama.cpp, custom OpenAI-compatible, and its own ProxyAI cloud) and supports local inference via a bundled llama.cpp submodule. It implements an agent framework with a tool system (read, write, edit, bash, web search, diagnostics, debugger control), MCP (Model Context Protocol) client for external tool servers, and ACP (Agent Client Protocol) for external agent integration. The architecture follows IntelliJ Platform conventions: services, actions, tool windows, settings via PersistentStateComponent, and editor listeners. The codebase is a mix of Kotlin (dominant) and Java, with Gradle build system and extensive use of coroutines for async operations.
The JetBrains MCP Proxy Server is a Node.js application that acts as a middleware between MCP-compatible clients (such as Claude Desktop or VS Code) and JetBrains IDEs equipped with the MCP Server plugin. It discovers the IDE's MCP endpoint by scanning a predefined port range (63342-63352) or using a specified IDE_PORT environment variable, caches the endpoint, and periodically verifies its availability. The proxy then exposes an MCP server over stdio, forwarding tool listing and tool invocation requests to the IDE's HTTP-based MCP endpoint. The implementation uses the Model Context Protocol SDK for stdio communication and node-fetch for HTTP requests, featuring error handling, logging, and endpoint caching with periodic refresh.