nvim-tree/nvim-tree.lua is a mature Neovim file explorer plugin written entirely in Lua. It provides a tree-view sidebar with file system operations, git status indicators, diagnostic integration (LSP/COC), file filtering, bookmarks, clipboard management, and extensive customization. The architecture is modular, with clearly separated concerns: an explorer module handles tree construction and traversal; a view module manages the floating or split window; a renderer with a decorator pattern applies icons and highlights; a git module runs async git status queries; and an actions layer handles file create/rename/delete/trash. It uses an internal event system, filesystem watchers via libuv, and a public API for user extensions. The codebase demonstrates solid Lua craftsmanship, including a fluent node iterator, a classic OOP library, and a config validation recursive checker. It is actively maintained, with continuous adaptation to Neovim API changes and cross-platform support.
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.
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.
lua-resty-logger-socket is a Lua library for Nginx (using ngx_lua) that provides nonblocking remote logging. It buffers log messages in memory and sends them to a remote log server (via TCP, UDP, or Unix domain socket) when the buffer reaches a configurable size or when manually flushed. The library implements efficient buffering with two-level buffers to minimize string concatenation, buffer reuse to prevent memory leaks, retry logic for connection and send failures, periodic flushing, and graceful handling of Nginx worker shutdown to flush remaining logs. It supports SSL with SNI and certificate verification.
obsidian.nvim is a Neovim plugin that integrates Obsidian vault functionality directly into Neovim. It provides note creation, linking, completion, navigation, image handling, synchronization, and templating features for markdown-based notes. The plugin leverages Neovim's API for LSP integration, autocommands, buffer management, and picker interfaces (telescope, fzf, snacks, mini) to deliver an Obsidian-like experience within Neovim. It maintains a cache of note metadata for performance and supports multiple workspaces with per-workspace overrides. The architecture is modular, separating concerns into commands, LSP handlers, note management, workspace handling, caching, search, picker abstraction, and completion sources.
KOReader is a document viewer application primarily designed for e-ink readers, supporting a wide range of formats including PDF, EPUB, DjVu, CBZ, and more. It provides a full-featured reading experience with file management, annotation, dictionary lookup, OPDS catalog browsing, Calibre integration, cloud storage, and extensive customization through a plugin system. The architecture is a monolithic Lua application built on a custom widget toolkit with an event-driven UI manager, platform-specific device abstraction layers (Kindle, Kobo, PocketBook, reMarkable, Android, SDL), and a robust caching and rendering pipeline. Key entry points are `reader.lua` for the main application and `kodev` for development/testing. The codebase is large and mature, with a strong emphasis on performance and e-ink optimization, but shows some technical drift in the form of deprecated code paths, platform-specific hacks, and a fragmented keyboard layout system.
Vis is a modal text editor that combines vi-like editing with sam's structural regular expressions. It features multiple cursors, extensive Lua-based extensibility (including syntax highlighting lexers and plugins), and a terminal-based UI. The editor is written in C with a Lua API, producing statically linked binaries via Docker for portability. Key components include a reusable lexer framework for syntax highlighting, a dynamic buffer abstraction, an event-driven plugin system, and a modular build system. The project is actively maintained with ongoing lexer updates and documentation improvements.
Luban is a game configuration solution that transforms structured data (Excel, JSON, YAML, Lua, XML, etc.) into strongly-typed code and serialized data for multiple target languages (C#, Java, Go, C++, Rust, Python, TypeScript, Lua, etc.) and data formats (binary, JSON, protobuf, flatbuffers, msgpack, BSON, etc.). It is implemented as a .NET 8 console application with a plugin-based pipeline architecture: schema loading → data loading → validation → code generation → data export. The core engine (Luban.Core) provides extensible interfaces for custom loaders, validators, code targets, and data targets, all discovered via assembly attributes. Code generation uses Scriban templates with language-specific extensions, and data serialization employs a custom compact binary protocol (ByteBuf). The tool is widely used in game development for managing configuration data across engines like Unity, Unreal, Godot, and Cocos.
Dora SSR is a production-grade cross-platform game engine designed for rapid development directly on target devices (mobile, desktop, web). The engine is a monolithic C++ core that provides 2D/3D rendering (bgfx), physics (JoltPhysics, PlayRho, Box2D), audio (SoLoud, libopenmpt), animation (Spine, DragonBones), UI (Yoga layout), and a full scene graph. It exposes scripting via multiple languages: Lua (with a custom binding generator), TypeScript (compiled to Lua via a vendored tstl fork), WebAssembly (via wasm3), Rust (via FFI), and C# (via P/Invoke). A built-in Web IDE (React/Monaco-based) allows coding and debugging from a browser on the same network. The engine also includes an AI coding agent with memory, skill tools, and preview session management, integrated into the IDE workflow. Over 50 CI workflows build for Android, iOS, Windows, macOS, Linux, and Web (Emscripten).
REPENTOGON is a comprehensive modding framework for the game The Binding of Isaac: Repentance. It extends the game's Lua API with hundreds of new functions, provides low-level hooking and assembly patching capabilities, integrates ImGui for developer tools, and adds features like custom item pools, save syncing, virtual room management, and achievement tracking. The architecture is a hybrid of a C++ DLL that injects into the game process and a set of Lua scripts that run in the game's Lua environment. Key entry points include the DLL main (dllmain.cpp) which initializes hooks and patches, and the Lua registration system (LuaInit.cpp) which exposes new classes and callbacks. The framework relies on reverse-engineered game structures, signature scanning, and runtime code modification to achieve deep integration. External dependencies include the game itself, Lua 5.4, ImGui, and several bundled libraries (glad, rapidxml, rapidjson, mINI). The codebase is large and actively maintained, with a strong focus on modder extensibility and bug fixing.
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.
SimpleUI is a KOReader plugin that provides a highly customizable, distraction-free user interface overlay for the KOReader e-book reader application. It replaces the default homescreen with a modular widget system (clock, currently reading, recent books, reading stats, cover deck, etc.), adds configurable top/bottom bars, quick settings bar, library enhancements (virtual browsing, cover overrides), reading statistics and streaks with heatmaps, backup/restore, and over-the-air updates. The plugin is implemented in Lua and deeply integrates with KOReader's widget framework, extensively monkey-patching core classes like FileChooser, TouchMenu, and TitleBar. Despite heavy coupling to KOReader internals, the codebase exhibits strong engineering practices: lazy loading, parameterized module factories (e.g., GridRenderer), custom caching layers (cover cache, stats cache), a reusable anti-aliased drawing library, and a self-contained i18n system with PO file parsing. The repository is actively maintained with a well-documented public API for external plugins to register quick actions. It is not a standalone application but a plugin that must be installed within KOReader. The primary risk is reliance on KOReader's internal APIs, which may break with upstream changes.
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.
This Neovim plugin renders indentation guides using virtual text, avoiding the 'conceal' feature. It provides highly configurable indentation guides, including support for tabs, mixed indentation, and multiple highlight groups. The architecture is modular: `config.lua` handles a hierarchical configuration system with merging, validation, and buffer-scoped overrides; `hooks.lua` implements an extensible type-safe hook system that allows other plugins or user configurations to modify every aspect of the rendering pipeline; `indent.lua` performs whitespace analysis and classifies each cell into an enum (TAB_START, TAB_FILL, etc.); `scope.lua` uses Treesitter to determine the current scope (e.g., function body) for highlighting; and `virt_text.lua` composes the final virtual text extmarks. The plugin refreshes on cursor movement, option changes, and scrolling, with built-in debouncing. It integrates with Neovim's `listchars` and supports repeat_linebreak for wrapped lines. Test coverage is moderate but exercise key components. The code demonstrates mature Lua engineering with careful Neovim version compatibility and a clean public API.
A Neovim plugin that integrates with AI CLI tools (opencode, claude, cursor-agent, gemini) to provide agentic coding workflows. It allows users to perform semantic searches, replace visual selections, run 'vibe' sessions for code generation, and get tutorials. The plugin manages state, request tracking, logging, and window management. It supports multiple providers, custom rules via SKILL.md files, and file completions. The architecture is modular with clear separation of concerns: providers, operations, extensions, and UI layers.
This repository is a comprehensive configuration package for the Rime input method engine, providing a curated set of input schemas, dictionaries, Lua scripts, and OpenCC conversion data. It is not a standalone application but a template package that users copy or integrate into their Rime setup (on Windows, macOS, Linux, Android, iOS). The project offers multiple Chinese input methods including full pinyin, various double pinyin layouts, Wubi 86/98, stroke, and T9, along with extensive English and emoji support. Its key value lies in the integration of high-quality dictionaries (rime-ice, Wanxiang, rime-frost) and advanced Lua extensions that add features like date/time, lunar calendar, calculator, unicode translation, automatic capitalization, and corrector filters. The configuration follows the Rime convention of custom.yaml overrides, allowing users to upgrade without losing personalizations. While the core is a set of configuration files, the Lua scripts and OpenCC data are reusable assets demonstrating strong craftsmanship.
Likwid is a comprehensive performance monitoring and benchmarking tool suite for HPC environments. It provides command-line tools (likwid-perfctr, likwid-pin, likwid-bench, likwid-powermeter, likwid-topology, etc.) and a C/Fortran/Lua library for reading hardware performance counters, managing CPU/GPU topology, controlling system features (turbo, prefetchers, RAPL power limits), and pinning threads. The architecture is modular: a core C library (liblikwid) handles low-level hardware access via MSR, PCI, MMIO, or a privileged daemon, while Lua scripts provide user-facing interfaces. External dependencies (Lua, hwloc, GOTCHA, cwisstable) are bundled. The codebase supports x86, ARM, POWER, and GPU (NVIDIA, AMD) architectures with per-architecture performance counter definitions. It is primarily an application tool, though its extensive hardware counter definitions and benchmark infrastructure also serve research purposes.
auto-dark-mode.nvim is a Neovim plugin that automatically switches the editor's background between dark and light mode based on the host operating system's appearance setting. It supports macOS (via `defaults read`), Linux (via `dbus-send` with optional `dbus-monitor` for event-driven updates), Windows (via `reg.exe`), and WSL/OrbStack. The plugin polls the system at a configurable interval (default 3000ms) or uses D-Bus monitoring on Linux for immediate updates. It provides user-definable callback functions (`set_dark_mode` and `set_light_mode`) that default to changing Neovim's `background` option. The architecture is modular: `init.lua` handles OS detection and setup, `interval.lua` manages polling/monitoring and theme synchronization, `health.lua` provides a `:checkhealth` diagnostic with benchmarking, and `types.lua` defines type annotations. The code is well-structured with graceful fallbacks for older Neovim versions (0.7.x) and comprehensive error handling for edge cases like running as root or missing system utilities. It is a focused, single-purpose plugin with clean separation of concerns.
This is a personal Neovim configuration repository for Neovim 0.12+, using a modular Lua setup with the built-in `vim.pack` plugin manager. The architecture is clean: `init.lua` loads core config modules (options, keymaps, autocommands, plugin manager, colorscheme, LSP) and auto-loads per-plugin configurations from `lua/plugins/`. The configuration is production-grade for daily development, featuring LSP integration (TypeScript, Rust, Lua, etc.), fuzzy finding via snacks.nvim, a custom statusline, Mason for tool management, and many quality-of-life plugins. The code is well-organized and demonstrates modern Neovim Lua API usage. It is not a generic library but a specific personal config that can serve as a reference or starting point for other Neovim users.
aux is a World of Warcraft Classic (1.13) AddOn that replaces the default auction house interface with an enhanced version. It provides advanced features for searching, posting, and tracking auction history, including customizable filters, automatic stacking and undercutting, historical value calculations, and tooltip enhancements showing item value, vendor prices, and disenchant prospects. The addon is event-driven, using WoW's API to react to auction house events, and employs coroutines for asynchronous operations like scanning auction house pages to avoid blocking the game interface. The architecture is modular, separating concerns into core functionality (caching, scanning, history, tooltip), GUI components, tab-specific logic (auctions, bids, posting, search), and utility libraries. Key systems include a coroutine manager for handling asynchronous tasks without freezing the UI, a schema-based persistence system for saving configuration and data, and a color metatables system for seamless text coloring in the game's interface. The addon demonstrates solid engineering practices with clear separation of concerns, reusable utility modules, and appropriate use of WoW's event and scripting models. While the codebase includes some TODO comments indicating areas for improvement, it remains functional and well-maintained for its target platform. The lack of external dependencies and focus on the static WoW Classic 1.13 API minimizes technical drift concerns. The addon is actively used, as evidenced by its star and issue count, and continues to receive updates.