Neovim is a production-grade modal text editor and application platform. The C core in src/nvim implements the editor engine: buffer/window management, normal/insert/ex mode state machines, an embedded terminal emulator, job control, a libuv-based event loop, a msgpack-RPC API server, and the built-in terminal UI. Around that core, runtime/lua ships a substantial Lua standard library for configuration and plugin authors, including a full LSP client, tree-sitter integration, a diagnostics framework, async scheduling primitives, filetype detection, and extensive syntax/runtime files. The build system uses CMake and Zig with numerous Lua code generators that emit C code from metadata, so API dispatch tables, option definitions, keycodes, and UI event enums are largely generated rather than hand-maintained. Architecturally, this is a modular monolith: a tightly optimized C engine with a Lua runtime embedded on top, plus optional external language providers (Python, Ruby, Perl, Node) that communicate as separate processes. Entry points include src/nvim/main.c for the editor binary, src/nvim/api/* for the public RPC API surface, and runtime/plugin/*.lua for built-in features. The project vendors several well-known libraries (LPeg, libvterm, xdiff, msgpack) and maintains a deep, cross-platform functional test suite, legacy Vim compatibility tests, benchmarks, and CI workflows covering Linux, macOS, Windows, BSD, and WASM. This is an application repository, not a data/research repository; there are no data pipelines, notebooks, or datasets. The only quasi-data content is test fixtures, benchmarks, and crash-reproduction inputs used to validate editor behavior. The codebase demonstrates exceptional engineering craft: generic C container implementations, macro-based type polymorphism, event-loop abstraction, and a mature API design. Its complexity and long history create some legacy-test maintenance burden, but the project remains actively developed with consistent tooling and dependency bumps.
This repository is the core implementation of **coc.nvim**, a powerful Language Server Protocol (LSP) client and extension host for Neovim and Vim. It transforms these editors into full-featured IDEs by managing the lifecycle of language servers and providing rich features like intelligent code completion, diagnostics, refactoring, navigation, and snippet expansion. The architecture is a monolithic Node.js backend that communicates with the editor via RPC (`@chemzqm/neovim`), with a Lua bridge for performance-critical text operations and a sophisticated extension system that allows users to install and manage third-party plugins. The codebase demonstrates a high degree of engineering craftsmanship. It features a clean, event-driven architecture with extensive use of the Disposable and CancellationToken patterns for resource management. Notable subsystems include a highly optimized fuzzy matching engine with WASM support, a complete Model Context Protocol (MCP) server for AI agent integration, a robust configuration system with layered scoping, and a secure download/extraction utility. The project maintains an exceptionally large and well-structured test suite covering unit, integration, and handler-level scenarios. Currently, the project is in an **active** maintenance state with very low technical drift. It aggressively tracks the latest Node.js versions and LSP protocol extensions. While the sheer size of the codebase introduces some inherent complexity and a few deprecated internal APIs, the overall architecture is sound, the code is well-factored, and several components are genuinely reusable in other projects. It stands as a benchmark for how to build a complex, high-performance editor plugin.
This is a Neovim plugin that animates the cursor with a smear effect, inspired by Neovide's animated cursor. It works in any terminal by using floating windows and Unicode block characters to render a smooth, physics-based trailing cursor. The plugin listens to cursor movement events and interpolates the cursor position using a spring-damper system, drawing the smear as a quad with sub-cell precision. It supports configurable stiffness, damping, particles, and various rendering modes (vertical bar, horizontal bar, diagonal blocks, braille). The codebase is modular, with clear separation between animation logic, drawing, color management, and event handling. The drawing module is particularly noteworthy for its sophisticated use of Unicode symbols to achieve anti-aliased-like rendering in a terminal environment.
LazyVim is a curated Neovim configuration distribution and framework built on top of the lazy.nvim plugin manager. It provides a fast, modular, and opinionated IDE setup out of the box, with sane defaults for options, keymaps, and autocmds, plus an extensive system of optional 'extras' covering languages, editors, AI tools, UI enhancements, and more. The core architecture is a set of well-structured Lua modules that define a setup function, health checks, LSP integration, formatting, picker abstraction, and root directory detection. Users customize by adding plugin specs in their own lua/plugins/ directory or by enabling extras via the :LazyExtras command. The codebase is actively maintained with frequent releases, thorough testing, and detailed changelogs covering breaking changes and migrations. Although primarily a Neovim configuration, it exhibits application-level patterns such as a formal plugin specification API, an abstraction layer for pickers, and a modular extra system that could inform other tool configuration frameworks.
Overseer.nvim is a robust task runner and job management plugin for Neovim, enabling users to define, execute, and manage asynchronous commands directly within the editor. It supports a wide array of build tools and task frameworks through extensible templates, including Make, npm, Cargo, Just, and VS Code tasks. The plugin features a modular architecture built around an entity-component system, where tasks are augmented with composable components that hook into lifecycle events (start, output, exit, result) for custom behavior such as diagnostics integration, quickfix updates, notifications, and output parsing. It provides a rich UI with a sidebar task list, floating output windows, and in-buffer task editors, along with keymap configuration and integrations with neotest, lualine, and nvim-dap. The codebase is well-organized with clear separation of concerns, exposing reusable utilities for shell escaping, output parsing, keymap definition, and window layout management.
This is a Neovim configuration repository that sets up a modern, feature-rich development environment. It uses lazy.nvim for plugin management and configures LSP support, completion (via blink.cmp), keybindings, and various quality-of-life enhancements. The configuration is modular, with separate files for options, keymaps, LSP initialization, plugin configurations, and filetype-specific behaviors. It demonstrates solid Neovim Lua programming practices with thoughtful customizations for productivity.
render-markdown.nvim is a Neovim plugin that transforms raw Markdown files into a richer, more readable in-editor experience. Instead of opening an external preview window, it hooks into Neovim's tree‑sitter parser to understand the Markdown AST and overlays virtual text, highlights, signs, and concealments directly onto the buffer. It handles headings, code blocks, tables, checkboxes, callouts, LaTeX math, wikilinks, HTML tags, and YAML frontmatter, with full support for custom icons and per‑element styling. The plugin is pure Lua and requires Neovim ≥ 0.9.0 (recommended ≥ 0.10.0) and a Nerd Font for optimal icon display. The architecture is modular and layered. The main entry point `setup()` in `init.lua` merges user configuration with default presets and per‑buffer overrides. The `core/` directory manages the rendering lifecycle: `manager.lua` attaches to buffers and schedules renders, `handlers.lua` dispatches per‑language tree‑sitter parser requests, and `ui.lua` applies the resulting extmarks to visible windows. Each Markdown element (heading, code block, table, etc.) has its own renderer under `render/markdown/`, all inheriting from a common base class in `render/base.lua`. Utility modules in `lib/` provide reusable primitives for interval arithmetic, extmark lifecycle, virtual text construction, line manipulation, and configuration schema validation. The plugin also integrates with completion engines (nvim‑cmp, blink.cmp, coq_nvim) through a shared completion source in `integ/source.lua`. Code quality is high: the codebase includes an extensive test suite (unit, integration, and visual regression tests), benchmarks for performance on large files, a health check for dependencies, and a LuaRocks CI pipeline. The documentation includes a custom handler interface for user extensions, detailed troubleshooting guides, and auto‑generated type documentation. Despite a large configuration surface, schema validation and preset overrides keep the system flexible yet robust. The main risks are dependency on tree‑sitter grammar internals and Neovim API version changes, but the project is actively maintained and adapts quickly to ecosystem shifts.
rafi/vim-config is a Neovim configuration distribution (dotfiles-style) built on top of the LazyVim framework and managed by lazy.nvim. It transforms vanilla Neovim into a full IDE: lazy-loaded plugins provide LSP via nvim-lspconfig + mason.nvim, completion via blink.cmp (or nvim-cmp as an extra), telescope/snacks pickers, git workflows (gitsigns, diffview, neogit, blame), treesitter syntax, and a heavily customized lualine statusline. The runtime entry point is init.lua → lua/rafi/config/lazy.lua, which bootstraps lazy.nvim, imports the LazyVim framework plus ~15 core plugin-spec modules under lua/rafi/plugins/, and layers custom options, keymaps, and autocommands on top of LazyVim defaults via targeted User autocmds. An 'extras' system (registered in lua/rafi/config/init.lua) exposes ~50 opt-in plugin specs — colorschemes, language packs, org-mode tools, UI widgets — toggleable via :LazyExtras, making the distribution both opinionated and modular for fork-and-extend use. The codebase is idiomatic Lua organized into config/, plugins/, and util/ namespaces. It makes sophisticated use of lazy.nvim's spec merging (optional = true, opts = function(_, opts) patterns), a metatable-driven util facade (lua/rafi/util/init.lua) that lazily loads submodules, and recent Neovim APIs (vim.diagnostic.jump, nvim 0.11 features, tree-sitter-manager instead of the deprecated nvim-treesitter ensure_installed). Highlights for reuse include a small completion/snippet helper that abstracts LuaSnip vs native vim.snippet, color-theory utilities, a floating preview helper, and filetype plugins with proper undo_ftplugin hygiene. Documentation is extensive but partially stale: the README references paths that no longer exist in the tree (e.g. lua/rafi/plugins/lsp/keymaps.lua, lua/rafi/util/contextmenu.lua), so the code is the reliable source of truth. Dependencies: Neovim ≥ 0.11.2, git, lazy.nvim, LazyVim, and roughly 80 third-party Neovim plugins pinned via lazy-lock.json. Optional external CLIs (rg, fd, fzf, bat, zoxide, lazygit) improve picker and git behavior but degrade gracefully. This is not a data repo; it contains no pipelines, notebooks, or datasets. It is an application-distribution-style repo: a carefully engineered editor config demonstrating mature Neovim plugin-spec and Lua patterns.
no-neck-pain.nvim is a Neovim plugin that centers the focused buffer in the middle of the screen by creating empty side buffers. It provides a non-opinionated, highly configurable zen-like editing experience without the intrusive UI changes typical of other 'distraction-free' plugins. The plugin manages window layout across multiple tabs, supports splits/vsplits, and integrates with popular file trees (NvimTree, Neo-tree), dashboards (alpha, snacks), and other tools like undotree, neotest, nvim-dap-ui, outline, and aerial. The architecture is modular Lua with clear separation into configuration, state management, UI creation, color handling, and utility modules. The core logic revolves around dynamic layout scanning via Neovim's winlayout API, event-driven re-initialization, and per-tab state tracking.
This Neovim plugin provides a polished interface for invoking LSP code actions (refactorings, quickfixes, etc.) with real-time diff previews. It supports multiple picker frameworks (telescope, fzf-lua, snacks, vim.ui.select, and a custom buffer picker) and diff backends (vim, delta, difftastic, diff-so-fancy). The architecture is modular: a finder module collects actions from all LSP clients, filters and sorts them, then passes them to a configurable picker. The plugin handles action resolution (LSP resolveProvider), preview generation, and application of workspace edits. It is well-structured with base classes for pickers, previewers, and diff backends, making it easy to extend. The buffer picker is particularly sophisticated, offering hotkeys, category grouping, nested group support, and auto-preview.
milli.nvim is a Neovim plugin for animated ASCII splash screens. It provides both pre-rendered splash animations (like fire, blackhole, skeleton) and live procedural shaders (plasma, rain, doomfire, starfield) all implemented in pure Lua using Neovim’s extmarks for coloring. The plugin integrates seamlessly with popular dashboard plugins (dashboard-nvim, alpha-nvim, snacks.nvim, mini.starter) via autocmds and preset functions. It also includes a community registry for sharing splash data, with a sandboxed loading mechanism to prevent arbitrary code execution. The codebase demonstrates careful engineering: anchor-based positioning to handle variable terminal sizes, color-run optimisation to stay within Neovim’s highlight-group limit (E849), and deterministic pseudorandom number generation in shaders to avoid corrupting math.random. The external CLI tool (npm package `milli`) allows users to generate their own splashes from images or GIFs, and the data format is simple and portable. Overall, it is a well-crafted, feature-rich plugin with clear architecture and several reusable patterns.
NvChad is a Neovim configuration framework written in Lua that provides a modular, lazy-loaded base setup for Neovim. It enhances the editor with UI improvements (statusline, tabufline, theme picker), plugin management via lazy.nvim, and integrations for LSP, treesitter, telescope, and other popular plugins. The codebase is organized into distinct modules for options, mappings, autocommands, and plugin configurations, allowing users to import it as a plugin and override settings as needed. Key features include fast startup times (~0.02-0.07s), 93% lazy loading of plugins, and a focus on aesthetic UI components like NvCheatsheet and modern theme picker. The project is actively maintained with recent commits and demonstrates strong engineering practices for Neovim Lua configuration.
quicker.nvim is a Neovim plugin that replaces the default quickfix and location list windows with an enhanced, feature-rich interface. It provides improved styling with syntax highlighting (treesitter and LSP), context line expansion around matched results, and an editable quickfix buffer that allows applying bulk text changes across multiple source files on save. The plugin is implemented as a single modular Lua library using Neovim's `quickfixtextfunc` hook for rendering and leverages async processing for highlighting performance. It includes a suite of helper APIs for toggling, opening, closing, refreshing, and configuring the quickfix window. The codebase is well-structured, thoroughly tested, and actively maintained by a prolific Neovim plugin author.
onedark.nvim is a Neovim 0.9+ colorscheme plugin implementing the Atom One Dark and One Light themes with Lua and TreeSitter support. The codebase provides 8 theme styles (dark, darker, cool, deep, warm, warmer, light), comprehensive TreeSitter highlight definitions (modern @-prefixed captures), LSP semantic token integration, and support for over 24 plugins (nvim-cmp, telescope, lualine, indent-blankline, etc.). It includes a robust test suite with automated highlight group verification and manual visual testing files. The architecture is modular: palette.lua defines raw color values per style, colors.lua selects and merges with user overrides, highlights.lua maps groups to colors with configurable code styles (italic, bold), and init.lua handles setup/loading/toggling. The utility module provides reusable color blending functions. The repository is actively maintained with frequent releases, detailed changelogs, and responsive issue triage. While primarily a Neovim plugin, its color handling and test patterns could inspire similar theme implementations.
GNvim is a GTK4-based Neovim GUI written in Rust. It communicates with Neovim via the MessagePack-RPC protocol, providing a native desktop experience with features like floating windows, popup menus, tabline, cmdline, and smooth animations for cursor and scrolling. The architecture is a single Rust binary split into a workspace: the main `ui` crate contains the GTK4 frontend with custom widgets (e.g., Grid, GridBuffer, Cursor, Fixedz, Popupmenu, Shell), and the `nvim-rs` library crate provides a reusable, async RPC client for Neovim with auto-generated API bindings. The system's entry point is `ui/src/main.rs`, which registers resources and launches the GTK application. Data flows bidirectionally: Neovim sends UI events (redraw, options, notifications) as RPC messages, which are deserialized into Rust types and applied to the GTK widget tree; user input (keyboard, mouse) is captured by GTK event controllers and sent back to Neovim as RPC calls. The codebase is well-structured, modular, and follows modern Rust async patterns, with extensive use of GTK4's property system and custom layout managers for complex UI composition.
This is a Neovim configuration distribution that provides a highly customized editing environment with a layer-based architecture inspired by Spacemacs. It implements a modular system where functionality is organized into layers (editor, ui, git, completion, devops) each containing their own configurations, keymappings, and plugins. The configuration uses lazy.nvim for plugin management, provides extensive LSP support, theme integration with dozens of color schemes, and keybindings following Spacemacs conventions using the spacebar as the leader key. The system loads user configuration from ~/.cosmos-nvim.lua with fallback to a sample configuration, processes layers to apply options and settings, registers keymappings with which-key.nvim, and manages plugins through lazy.nvim.
This Neovim plugin provides a floating window for entering ex-commands, featuring tab completion, history navigation (with optional smart history), and customizable keybindings. It is built on top of the nui.nvim library and offers a clean API for configuration and extension via hooks. The plugin handles compatibility across different Neovim versions (pre and post 0.7) for keymap settings. The implementation is focused and modular, separating concerns between UI setup, state management, and user interaction.
SQLua.nvim is a Neovim plugin that transforms the editor into a SQL IDE. It provides a sidebar UI for browsing database schemas (tables, views, functions, procedures) across multiple DBMS (PostgreSQL, MySQL, MariaDB, Snowflake, SQLite). Connections are configured via a JSON file with JDBC-like URLs. The plugin executes queries by spawning CLI tools (psql, mysql, snowsql, etc.) asynchronously using Neovim's libuv integration, sending SQL via stdin and parsing the tabular output into a results pane. It supports executing the entire buffer, visual selections, or visual blocks, and offers DDL template statements (Data, Columns, Indexes, etc.) that generate queries on click. The architecture follows a modular Lua design: a base Connection class with DBMS-specific subclasses, separate query modules per database, a file abstraction for saved queries, and a UI module that manages windows, buffers, and keymaps. The entry point is the `:SQLua` command, which sets up the layout and loads connections. The plugin relies solely on Neovim 0.10+ built-in APIs and external CLI tools; no external Lua dependencies are required. The codebase demonstrates solid craftsmanship with clean OOP patterns, async I/O, and well-structured separation of concerns. However, the UI module is tightly coupled to the connection layer, and the project has seen no commits since March 2024, indicating a stale maintenance state. The core utility functions, particularly the JDBC URL parser in utils.lua, are self-contained and could be reused in other Lua projects.