Awesome GitHub RepositoriesEmbedded Scripting Engines

Huginn is an open-source automation platform that functions as an event-driven task automator and webhook integration engine. It enables the creation of agents that monitor web data and automate tasks across various web services, operating as a self-hosted web scraper and JavaScript workflow orchestrator. The system uses a directed graph of event flows to route and transform data between external APIs. It differentiates itself by allowing custom JavaScript execution within workflows to modify data payloads and by integrating human-in-the-loop automation to insert manual judgment or data entry

Trilium is a hierarchical personal knowledge base and digital garden tool designed to organize information into a tree of linked nodes. It functions as a JavaScript programmable wiki and a self-hosted note server, allowing users to maintain a private database of documents synchronized across multiple devices. The platform distinguishes itself through an embedded scripting engine for automating tasks and a REST API that exposes internal data and actions to external tools. Users can further extend the system by modifying the user interface layout and styling through a custom theme engine. The

InfluxDB is a high-performance time-series database designed for collecting, storing, and querying time-stamped metrics and event data. It functions as a columnar time-series store and a real-time analytics engine, providing a network-accessible interface for retrieving and analyzing temporal records. The system utilizes a specialized columnar storage format to support high ingestion rates and efficient data retrieval. It incorporates a programmable runtime for executing custom plugins and triggers, including integration for processing and transforming incoming data streams. The platform cov

k6 is a performance testing framework used to measure the scalability and stability of network services and APIs. It functions as a JavaScript load testing tool that uses a Go engine to simulate concurrent user traffic. The tool enables the enforcement of service level objectives by comparing response time percentiles against quantitative performance thresholds. It also operates as a performance regression tool for continuous integration pipelines and a browser performance testing tool that executes scripts within a bundled headless browser instance. Its capabilities cover workload scenario

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

Stetho is a debug bridge that connects Android applications to Chrome Developer Tools. It allows for the real-time inspection of network traffic, internal application state, and the user interface layout directly within a desktop browser. The project provides specialized inspectors for analyzing Android-specific components. This includes a network inspector for capturing HTTP requests and responses, an SQLite database browser for querying local storage, and a view hierarchy inspector for mapping UI elements and styles. Additional capabilities cover runtime execution via an embedded JavaScrip

This project is an NGINX module that embeds the Lua scripting language directly into the server environment. It functions as a request processor and response filter, enabling the execution of scripts to handle HTTP requests, generate dynamic content, and manage server behavior without external application calls. The module provides a shared memory dictionary and cache manager, allowing data to be stored and retrieved across all active worker processes. This capability supports the collection of high-performance server metrics and the synchronization of information across concurrent processes.

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

Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime customization. It provides a C-based scripting engine and a prototype-based object model that utilizes associative arrays and metatables to implement inheritance and complex data structures. The language features a cooperative multitasking system that manages concurrent execution threads via coroutines and an incremental garbage collector for automatic memory management. It includes a safe code sandbox to isolate global state and run untrusted scripts within a protected envir

Tile38 is an in-memory geospatial database that uses the Redis protocol for communication and query execution. It serves as a distributed spatial store for points and polygons, featuring high availability through leader-follower replication and disk-based persistence. The system includes a real-time geofencing engine that monitors virtual geographic boundaries and triggers webhooks when objects enter or exit specified areas. It further distinguishes itself with an embedded Lua scripting engine for server-side data transformations and a built-in vector tile server for efficient map visualizati

ChakraCore is an embedded JavaScript engine designed to be integrated as a library within a host application. Its primary purpose is to provide a programmable scripting layer and a lightweight runtime environment for executing JavaScript code and managing state via a programmatic interface. The project focuses on bridging high-level scripting with low-level system calls through a C API. This allows developers to implement custom scripting engines and embed JavaScript execution directly into applications to enable task automation and functional extensions. The engine utilizes a bytecode-based

Otto is a Go implementation of a JavaScript interpreter and embedded scripting engine. It provides a runtime environment for executing JavaScript code within native applications and includes a parser that converts source code into an abstract syntax tree for analysis and processing. The project enables the creation of custom scripting interfaces by binding native Go functions into the JavaScript global scope. It also includes a utility to translate JavaScript regular expression patterns into compatible formats for other programming languages. The engine supports safe script sandboxing throug

Yaegi is a Go language interpreter and embedded scripting engine that executes Go source code at runtime without requiring a separate compilation step. It provides a mechanism for evaluating Go expressions and files dynamically, functioning as both a library for compiled applications and a standalone read-eval-print-loop environment. The project enables the integration of dynamic Go scripts into compiled programs to allow for runtime extensibility and plugin development. It facilitates the conversion of interpreted symbols from evaluated scripts into usable interfaces and types within a compi

Wren is a bytecode-compiled, class-based scripting language designed as an embeddable programming language. It provides a lightweight runtime and interface for executing dynamic scripts directly within host software applications. The engine utilizes a single-pass compiler to transform source code into compact bytecode and a virtual machine to process those instructions. It supports concurrent task execution through a system of lightweight fibers and coroutines. The language implements a class-based object model with dynamic message dispatch for organizing code into reusable components. It al

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

Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded scripting engine that allows Go applications to execute JavaScript code and integrate a programmable scripting layer without relying on Cgo or external native dependencies. The project functions as a bridge between Go and JavaScript, enabling bidirectional data exchange and function invocation. It allows Go hosts to expose native structs, slices, and maps as JavaScript objects and arrays, while providing mechanisms to export script values and functions back into native Go type

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.

mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into a compact, platform-independent bytecode that executes on a register-based virtual machine, and exposes a stable C API for host programs to initialize the interpreter, load bytecode, and invoke Ruby methods at runtime. The interpreter distinguishes itself through a tightly coupled parser and compiler that performs lexical analysis, syntax parsing, and bytecode generation in a single pass without constructing an intermediate AST, minimizing memory overhead. It also includes a

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

Rhai ist eine eingebettete Skript-Engine und eine dynamisch typisierte Sprache, die für die Integration in Rust-Anwendungen entwickelt wurde. Sie fungiert als Compiler für abstrakte Syntaxbäume (AST) und als native Interop-Schicht, die es Entwicklern ermöglicht, Rust-Typen und -Funktionen für eine bidirektionale Kommunikation in eine Skriptumgebung zu mappen. Das Projekt dient als Framework zur Erstellung anpassbarer domänenspezifischer Sprachen. Es erlaubt die Definition benutzerdefinierter Operatoren, Syntax und eingeschränkter Ausführungsumgebungen, was die Erstellung spezialisierter Sprachen mit maßgeschneiderten Funktionsumfängen ermöglicht. Die Engine deckt ein breites Spektrum an Funktionen ab, darunter ressourcenbeschränktes Sandboxing für sichere Ausführung, modulare Code-Organisation und umfassende Datenverarbeitung für numerische, String- und Binärtypen. Zudem bietet sie Werkzeuge für AST-Manipulation, Serialisierung des Ausführungszustands sowie Laufzeit-Observability durch Call-Stack-Inspektion und Debugging-Schnittstellen. Die Engine ist für den plattformübergreifenden Einsatz auf jeder CPU und jedem Betriebssystem konzipiert, das vom nativen Compiler unterstützt wird.