Solarized Osaka is a Neovim colorscheme plugin that implements a Solarized-inspired dark and light theme with extended colors for modern Neovim features and plugin support. The codebase is a monolithic Lua plugin with entry points in `colors/solarized-osaka.lua` and `lua/solarized-osaka/init.lua`. It works by defining a color palette via HSL/HPLUV color space conversions, then generating Neovim highlight groups and optionally producing theme files for external applications (terminals, tmux, fish, etc.) via a template system. The architecture is clean: a config module merges user options, a colors module computes the palette, groups modules define highlight groups per plugin, and a theme module applies them. The plugin has no runtime dependencies beyond Neovim 0.7.2+. Notably, the repository includes standalone implementations of HSL and HSLuv color space conversions (hsl.lua, hsluv.lua) and a utility function for perceptually brightening colors (util.brighten). These components are reusable in other Lua projects. The extras generation system is also well-structured, though tightly coupled to the theme.
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.
This repository is a KOReader plugin called 'Project: Title' that replaces the default file browser and history with alternative display modes: cover grid, cover list, details list, and filename list. It extracts book metadata and cover images, caches them in a SQLite database (with zstd compression), and displays progress bars, series information, tags, and custom book status screens. The plugin monkey-patches core KOReader widgets (FileChooser, FileManager, Menu, BookStatusWidget) to inject its own UI components. It also provides background metadata extraction, folder cover generation, and a user-patch extension mechanism. The code is written in Lua and is tightly integrated with KOReader's internal APIs, making it non-portable outside that ecosystem. However, several internal modules (gettext proxy, performance debugger, user-patch template) demonstrate reusable patterns for other KOReader plugins.
This is a Neovim plugin written in Lua that wraps PlatformIO CLI commands for embedded development. It provides user-friendly Neovim commands (e.g., :Pioinit, :Piorun, :Piomon) to initialize projects, build/upload firmware, monitor serial ports, manage libraries, and generate LSP configurations. The architecture is modular: each command resides in its own file under lua/platformio/, with a shared utils module for terminal management and a picker abstraction layer that supports telescope and vim.ui.select backends. The plugin is well-structured, with clear separation of concerns, validation of user configuration, and a health check. It is a solid implementation of a typical Neovim plugin, but not exceptional. The picker abstraction is the most reusable component.
nvim-test is a Neovim plugin that provides a unified interface for running tests across multiple programming languages. It integrates with Neovim's terminal system to execute test commands (like jest, pytest, etc.) and displays results in a split window. The plugin features language-specific runners that use tree-sitter queries to identify test functions and navigate to the nearest test from the cursor. Key components include a base Runner class for abstraction, utility functions for file path resolution, and terminal adapters for both built-in and toggleterm implementations. The plugin is actively maintained with recent commits and CI workflows, showing low technical debt as it relies on Neovim's stable APIs and external test runners without complex dependencies.
Conky is a free, lightweight system monitor for X11, Wayland, and macOS that displays system information on the desktop or in alternative output modes (console, file, HTTP). It collects data from /proc, /sys, sysctl, and various APIs to report CPU, memory, disk, network, processes, sensors, audio players, mail, RSS, and more. The architecture is modular: data sources are registered as text objects with scan/print/free callbacks, output backends are selected at runtime (X11, Wayland, ncurses, console, file, HTTP), and Lua scripting provides configuration and extensibility via tolua++ generated bindings. A callback system handles periodic data fetching with deduplication and thread safety, and a priority queue supports top process sorting. The codebase is written in C++ with some C, uses CMake build system, and includes a comprehensive test suite using Catch2. It supports Linux, BSDs, Haiku, Solaris, and macOS with platform-specific backends. The project demonstrates several well-crafted reusable components: a generic priority queue, a callback system for periodic tasks, a typed configuration settings framework with Lua integration, a structured logging wrapper around spdlog, and a macro-generated X11 event variant pattern. These components exhibit non-obvious skill and can be extracted for use in other C++ projects. However, the codebase also shows signs of technical drift with bundled third-party libraries (Vc, tolua++, spdlog) that may lag behind upstream, and some platform-specific backends have incomplete implementations.
Kaitai Struct is an umbrella project that provides a declarative language for describing binary data structures and a compiler to generate parser code in multiple target languages. The repository coordinates submodules for the compiler, runtimes for various languages (Java, Python, Ruby, etc.), format definitions, visualizer, tests, benchmarks, and documentation. Users describe a format in a .ksy file, compile it with the kaitai-struct-compiler to generate language-specific parser code, and use the corresponding runtime to parse binary data. The project includes CI workflows for building the compiler and publishing artifacts, and maintains a collection of ready-to-use format descriptions.
cimgui is a C language binding generator and wrapper library for Dear ImGui, a popular C++ immediate-mode GUI library. It provides a programmatically generated C API (cimgui.h/cpp) that exposes both public and internal ImGui functions, structs, and enums, along with backend-specific wrappers for GLFW, SDL2/3, Vulkan, OpenGL, and DirectX11. The core of the project is a Lua-based code generator (generator.lua, cpp2ffi.lua) that parses ImGui C++ headers and emits C bindings, metadata files (JSON/Lua), and backend implementations. The repository includes example applications demonstrating usage with various graphics backends and a CMake-based build system for easy integration. While not a standalone application, it serves as a foundational library for embedding Dear ImGui in C projects or for generating FFI bindings to other languages (e.g., Python, Rust, C#). The generator is designed to be extensible, supporting custom configurations and inherited types, making it suitable for binding other ImGui-based libraries like cimplot or cimnodes.
This repository contains the Apache SkyWalking Nginx Agent, a Lua-based library that provides distributed tracing capabilities for Nginx and OpenResty deployments. The agent integrates with Nginx's Lua API to automatically trace incoming and outgoing HTTP requests, propagate trace context between services using custom headers (sw8 and sw8-correlation), and report trace data to a SkyWalking OAP server. The architecture uses Nginx's phased execution model (init_worker, rewrite, body_filter, log) to manage the tracing lifecycle, with a shared dictionary for buffering trace segments and a timer for periodic reporting and heartbeats. The codebase demonstrates strong engineering practices with clear separation of concerns, comprehensive error handling, and performance optimizations like table pooling to reduce garbage collection pressure in LuaJIT. Several components show particular craftsmanship and reusability: the utility module provides high-performance table pooling and ID generation; the correlation context module implements lightweight context propagation via base64-encoded headers; and the segment reference module handles trace context serialization for cross-process tracing.
This is a Visual Studio Code extension providing comprehensive language support for Garry's Mod Lua (GLua). It delivers syntax highlighting, autocompletion, hover documentation, signature help, go-to-definition, find references, color picker, type hints, file previews (VTF/PNG), workspace scanning, global variable optimization, and a bytecode heatmap generator. The extension is built as a single Node.js process using the VS Code API, with a custom Lua parser (gluaparse) for AST analysis and a bundled gluac binary for LuaJIT bytecode manipulation. It downloads wiki data from a remote server and caches it locally. The codebase is well-organized into providers and commands, but is tightly coupled to the VS Code extension model and Garry's Mod-specific data sources, limiting direct reuse outside this context. A Python-based generator script for scraping the Facepunch wiki is also included as a separate tool.
This repository is a complete mirror of the World of Warcraft game client's UI source code, provided by Blizzard for reference by addon developers. It contains hundreds of official Blizzard addons written in Lua and XML, covering every in-game interface element from action bars and unit frames to auction house, map, and housing systems. The architecture is heavily event-driven and based on a mixin composition pattern (CreateFromMixins), with extensive use of frame pools, data providers, and secure/taint-aware coding. The codebase is production-grade and actively maintained alongside the game's releases, making it the authoritative reference for WoW addon development. While nearly all components are tightly coupled to WoW's proprietary APIs, several isolated utility libraries (color math, vector math, bit flags, export/import streams) demonstrate patterns that could be extracted for general Lua projects.
Hekili is a World of Warcraft addon that provides real-time ability recommendations for all DPS and tank specializations. It uses a custom engine that parses SimulationCraft Action Priority Lists (APLs) to evaluate game state—auras, cooldowns, resources, talents—and suggest the next best spell. The addon is modular, with per-expansion data folders (The War Within, Dragonflight, Shadowlands, etc.) and per-spec Lua files that register abilities, talents, auras, gear, and state expressions. It includes a custom condition compiler, a resource prediction system, and sophisticated combat log tracking to simulate upcoming events. The project has been discontinued due to Blizzard API changes, making future updates impossible. The architecture follows an event-driven singleton pattern: a core engine (Events.lua, State.lua, Utils.lua) manages game state, while each specialization module hooks into it via a factory pattern (Hekili:NewSpecialization). High craftsmanship is evident in the condition compiler that transforms SimC conditions into sandboxed Lua functions, the resource prediction framework using interval-based regeneration models, and the skeleton generator that auto-creates spec files from live game data. The codebase is large and includes legacy support for multiple expansions, but the core patterns are reusable and well-isolated. Key external dependencies are the WoW API, Ace3 libraries (AceAddon, AceGUI, AceConsole), LibStub, and SimulationCraft APL files. The UI features custom widgets like a syntax-highlighted APL editor and a popup slider. While the addon works for the current expansion (The War Within Patch 11.2), its maintenance is effectively frozen, and some logic contains TODO comments or hardcoded spell IDs that require regular updates.
This repository is a community-driven curated list (awesome list) of high-quality LÖVE (LÖVE2D) libraries, projects, and resources. It does not contain any runnable application or data pipeline; instead, it is a static markdown document with categorized links, supplemented by CI tooling for linting and link checking. The architecture is simple: a README.md file, a linting workflow (using awesome-lint and lychee), and a PowerShell script to sort entries. As a reference resource, it serves the LÖVE developer community by aggregating tools and assets, but it has no runtime behavior or data processing logic. Its quality as code is average due to minimal codebase; the list organization and maintenance are good.
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.
lua-resty-auto-ssl is an OpenResty (nginx + Lua) plugin that automatically issues and renews SSL/TLS certificates from Let's Encrypt (ACME) on the fly. It intercepts the SSL handshake via ssl_certificate_by_lua, checks for existing certificates in shared memory or persistent storage (file or Redis), and if missing, triggers certificate issuance using the dehydrated shell client. Domain validation is handled automatically via HTTP-01 challenges. The plugin supports multiple nginx workers, distributed storage, OCSP stapling, and configurable domain allow/deny policies. It is designed for high-traffic production environments but has been explicitly abandoned by its maintainers, with no active development since 2019. The codebase is well-structured with modular storage adapters, JSON adapters, and locking mechanisms, but relies on external shell processes (sockproc) and the dehydrated script, making it difficult to maintain and prone to issues with modern Let's Encrypt API changes. Given its abandoned status, it is not recommended for new projects; users should consider alternatives like acme.sh, acme-companion, or win-acme.
This repository is a heavily forked and customized version of the OpenWrt/LEDE build system, primarily focused on producing router firmware images with extensive proprietary MediaTek (Ralink) WiFi drivers, Lantiq DSL support, Quantenna firmware, and various custom utilities. The codebase is dominated by low-level kernel drivers for Wi-Fi chipsets (mt7615d, mt7603e, mt7612e) with thousands of lines of register definitions, hardware abstraction layers, and protocol state machines (802.11k/r/v, SAE, DFS, beamforming). It includes user-space daemons for embedded authentication (ead with tinysrp), network services (GRE, DHCPv6, WWAN), and firmware image tools (oseama, nvram, bcm4908img). The build system follows standard OpenWrt structure with top-level Makefile, package feeds, and include directives. The repository is a monolithic build system producing embedded Linux firmware, not a library or microservices application. It has high technical drift due to reliance on out-of-tree kernel modules, deprecated APIs, and aging cryptographic code. Reusable components are scarce but include standalone shell scripts for calibration data extraction and a self-contained SRP authentication library.
This repository implements an API Gateway based on Openresty and NGINX with LuaJIT for high-performance request processing. The system provides service discovery via Marathon integration, API key validation, HMAC/OAuth authentication, rate limiting, request/response transformation, and metrics collection. Architecture-wise, it uses a modular design with NGINX configuration files defining request processing phases, Lua modules for extensible functionality (validation, tracking, metrics), and external dependencies for service discovery (Marathon), caching (Redis), and metrics reporting (StatsD). Key entry points include the health-check endpoint (/health-check), metrics endpoint (/api-gateway-stats), and admin API (/tracking/* on port 5000). The gateway processes client requests through validation phases, proxies them to backend services, collects metrics throughout, and returns responses while supporting dynamic configuration reloading and remote config sync from S3.
This repository is a curated list of interesting open source projects organized by programming language. It contains markdown files with links and descriptions for each language. There is no application code, data pipelines, or analytical models. It serves as a reference directory for developers seeking open source projects to contribute to or learn from. The repository is well-maintained with recent updates and a large community following.