Awesome GitHub RepositoriesLua

Kickstart.nvim is a foundational boilerplate designed for building personalized Neovim environments. It provides a structured framework that uses Lua scripting to organize editor settings and custom logic, serving as a starting point for users to develop their own text editing workflows. The project distinguishes itself by integrating a centralized plugin manager that automates the installation, versioning, and lazy-loading of extensions. This orchestration minimizes startup latency while maintaining a declarative approach to managing the lifecycle of editor tools. The framework supports mod

LazyVim is a modular configuration framework and distribution for Neovim that transforms a base text editor into a comprehensive integrated development environment. It provides a structured system for managing, loading, and orchestrating editor extensions using Lua, designed to standardize professional development workflows through a curated collection of settings and plugins. The project distinguishes itself through a focus on performance and stability, utilizing deferred plugin initialization to minimize startup latency and resource consumption. Its architecture relies on a directory-based

This project is a package manager and configuration framework for Neovim, designed to orchestrate the lifecycle of editor extensions. It provides a centralized system for installing, updating, and tracking plugins while ensuring consistent dependency resolution across different environments through the use of lockfiles. The framework distinguishes itself by prioritizing startup performance and modularity. It employs event-based lazy loading to defer the initialization of extensions until specific user interactions, commands, or file types trigger their activation. To further accelerate the ed

Telescope is a fuzzy search interface for the Neovim text editor, designed to provide rapid access to files, buffers, and project-wide data. It functions as a keyboard-driven command palette that allows users to locate and navigate complex directory structures and codebase content through real-time filtering. The system is built on a modular architecture that utilizes a pluggable interface to fetch data from diverse sources, including file systems, version control repositories, and language server protocols. By separating input collection from data retrieval, it maintains a decoupled state ma

Tengine is an enhanced Nginx web server distribution designed for high-traffic environments. It functions as a high-performance reverse proxy, dynamic load balancer, and HTTP/3 proxy server, integrating an embedded Lua scripting engine to allow for custom business logic and dynamic request processing. The project distinguishes itself through a focus on modern transport protocols and efficiency, featuring native support for QUIC and HTTP/3 to reduce connection latency. It implements userspace UDP forwarding to bypass the kernel for higher throughput and provides the ability to dynamically upda

Webmagic is a Java web crawling framework designed for building scalable automated crawlers to download and process large volumes of web pages. It functions as a distributed web crawler and dynamic content crawler, utilizing an XPath HTML parser to locate and extract specific data points from page structures. The framework distinguishes itself through its ability to handle dynamic content by rendering JavaScript and executing asynchronous requests to extract data from non-static pages. It also allows users to define and execute crawler logic via scripting languages, enabling the update of col

Kakoune is a scriptable, modal text editor for the terminal that employs a client-server architecture. This model allows multiple terminal windows to connect to a single editing session, providing a programmable environment for managing source code and text. The editor is distinguished by its selection-first logic, where a text region must be predefined before a command is applied. It leverages regular expressions to manage multiple cursors and perform bulk edits across complex text patterns, and it integrates deeply with the shell by piping selections through external programs and filters.

xLua is a scripting bridge and C++ wrapper used to embed the Lua language into host applications. It facilitates bidirectional data exchange and function calls between scripts and the host environment. The project includes a runtime patching tool for replacing application logic and fixing bugs without requiring a system restart. It features a coroutine orchestrator that wraps asynchronous operations into linear code and a script validator that verifies digital signatures to ensure code authenticity and integrity before execution. To minimize memory overhead and garbage collection, the system

This project is an open-source 3D game engine designed for building high-fidelity games, simulations, and cinematic environments. It functions as a robotics simulation platform with native integration for ROS 2 to model robot controllers and sensors. The engine features a multi-threaded Forward+ physically based renderer that supports hardware-accelerated ray tracing and global illumination. The system is built on a modular extension architecture using Gems to add or replace features without modifying core binaries. It includes a native SDK for AWS cloud integration, enabling IAM authenticati

This project is a curated collection of guidelines and technical resources designed to improve C++ code safety, maintainability, and performance. It provides a comprehensive set of coding standards and best practices for establishing consistent naming, formatting, and structural patterns across C++ codebases. The guide offers specific technical advice on performance optimization, including methods for minimizing object copying, optimizing memory allocation, and reducing compilation cycles. It also provides a directory of tooling recommendations for implementing static analysis, fuzz testing,

GUI.for.SingBox is a desktop graphical interface client for managing the sing-box network proxy core. It functions as a network proxy manager and subscription manager, allowing users to configure routing rules, organize proxy profiles, and synchronize remote proxy server lists from external subscription providers. The application distinguishes itself through an event-driven plugin architecture and a script-based configuration middleware, enabling users to extend core functionality and programmatically modify configuration values. It also features a system for cross-platform settings synchroni

Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It serves as an embedded scripting engine and virtual machine that allows Go applications to execute Lua scripts and exchange data between the host and the script environment. The project provides a bytecode compiler to transform source code into a binary format for faster execution. It enables deep integration between the two languages by allowing the registration of native Go functions to be called from scripts, and the invocation of script functions directly from Go. The engine c

HAProxy is a high-performance TCP and HTTP proxy that distributes traffic across multiple backend servers to ensure availability and fault tolerance for critical services. It operates in either TCP or HTTP mode, with an event-driven, single-threaded reactor that handles tens of thousands of connections without context switching, and supports kernel-level data transfer to minimize memory usage and latency. What distinguishes HAProxy is its configuration-file-first design, where all load-balancing rules and runtime behavior are defined in a declarative text file parsed at startup. It embeds a L

Suricata is an open-source network intrusion detection and prevention engine that analyzes live network traffic in real-time to identify and alert on malicious activity. It operates as a rule-based threat detection system, matching traffic against user-defined signatures to detect known attack patterns and policy violations, and can be placed inline to actively block malicious packets before they reach their target. The engine inspects a wide range of application-layer protocols including HTTP, DNS, TLS, SMB, and MQTT, and supports high-performance packet capture through specialized hardware a

Dieses Projekt ist ein umfassender Leitfaden für das Schreiben von Neovim-Konfigurationen und Plugins unter Verwendung der Programmiersprache Lua. Es dient als Handbuch für die Nutzung der nativen Neovim-Lua-API zur Verwaltung von Buffern, Fenstern und Editor-Optionen. Der Leitfaden konzentriert sich auf die Interoperabilität zwischen Lua und Vimscript und bietet Anleitungen, wie Vimscript aus Lua ausgeführt und wie Lua-Funktionen aus Vimscript aufgerufen werden können. Zudem bietet er ein Framework für die Plugin-Entwicklung, das die Organisation von Code in externe Module sowie die Erstellung benutzerdefinierter Befehle und Key-Mappings abdeckt. Die Dokumentation umfasst weiterführende Funktionen wie die Automatisierung von Editor-Workflows, die Manipulation interner Variablen und die Verwaltung von Editor-Optionen. Sie enthält zudem Anleitungen zum Sourcing externer Dateien und zum Modifizieren von Buffer-Zeilen.

LuaJIT ist eine hochperformante Lua-Sprachimplementierung und ein Just-in-Time-Compiler. Es fungiert als eingebettete Skript-Engine und dynamischer Binär-Übersetzer, der portablen Bytecode während der Ausführung in nativen Maschinencode umwandelt. Das Projekt konzentriert sich auf hochperformantes Skripting durch die Übersetzung von Bytecode in architekturspezifische Anweisungen, um Ausführungsgeschwindigkeiten nahe an kompiliertem C-Code zu erreichen. Es nutzt eine leichtgewichtige Laufzeitumgebung, die auf minimalen Speicher-Overhead ausgelegt ist. Das System unterstützt die Verarbeitung binärer Daten mittels bitweiser Operationen und ermöglicht asynchrones Task-Management durch die Integration von C-Coroutines. Es bietet zudem Funktionen für die Laufzeit-Codegenerierung und die Erstellung benutzerdefinierter Maschinencode-Anweisungen.

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

Vale ist ein Markup-bewusster Prose-Linter und CLI-Tool, das darauf ausgelegt ist, redaktionelle Styleguides und Grammatikregeln über verschiedene Dokumentformate hinweg durchzusetzen. Es fungiert als YAML-basierte Styleguide-Engine, die Text auf Konsistenz in Tonfall, Rechtschreibung und Terminologie analysiert, während sie Nicht-Prosa-Elemente wie Code-Blöcke ignoriert. Das Projekt zeichnet sich durch ein flexibles Erweiterbarkeitsmodell aus, das es Benutzern ermöglicht, benutzerdefinierte Linting-Regeln mittels YAML-Konfigurationen, regulären Ausdrücken und externen Skripten für komplexe Validierungslogik zu definieren. Es unterstützt eine breite Palette an Dokumentationsformaten, darunter Markdown, AsciiDoc, HTML und Org-mode, und normalisiert diese Eingaben oft mittels XSLT, um einen einheitlichen Regelsatz anzuwenden. Das Tool deckt breite Funktionsbereiche ab, einschließlich linguistischer Bewertung für Lesbarkeitsmetriken und Grammatik, wörterbuchbasierter Rechtschreibprüfung und Terminologiemanagement zur Vermeidung inkonsistenter Formulierungen. Es bietet Integration über das Language Server Protocol für Echtzeit-Diagnosen in Editoren sowie Unterstützung für CI/CD-Pipelines und Git-Hooks zur Automatisierung der Prosa-Validierung. Vale kann innerhalb einer containerisierten Umgebung mittels Docker bereitgestellt werden, um eine konsistente Ausführung über verschiedene Plattformen hinweg zu gewährleisten.

Sol2 ist eine C++-Lua-Binding-Bibliothek, die als Interoperabilitätsschicht für die Integration von Lua-Skripten in C++-Anwendungen dient. Sie fungiert als Skripting-Wrapper und API-Toolkit, das die Ausführung von Lua-Code und die Verwaltung des geteilten Zustands innerhalb einer nativen C++-Umgebung ermöglicht. Die Bibliothek konzentriert sich auf das automatisierte Funktions- und Typ-Mapping, um native C++-Klassen und komplexe Datentypen mit der Lua-Skript-Engine zu verbinden. Sie bietet Mechanismen für den bidirektionalen Datenaustausch, wodurch kompilierte Logik und Variablen zwischen der Host-Anwendung und der Skript-Laufzeitumgebung synchronisiert werden können. Das System umfasst Funktionen für natives API-Binding, benutzerdefiniertes Typ-Mapping und die Ausführung von Skripten innerhalb einer C++-Umgebung. Es verwaltet zudem Ressourcen durch automatisches Speichermanagement und die Verfolgung von Objektlebenszyklen.