Projects sharing features with Sol2

Splash is a headless browser HTTP API and JavaScript rendering engine designed to convert dynamic web content into static HTML or images. It functions as a Lua-scriptable browser service that exposes browser automation and rendering capabilities through a RESTful interface for programmatic data extraction. The service distinguishes itself by allowing the execution of custom Lua scripts to automate complex user interaction sequences and page navigation. It provides the ability to switch rendering engines on a per-request basis to verify cross-browser compatibility and visual consistency. The

Rhai is an embedded scripting engine and dynamically typed language designed for integration into Rust applications. It functions as an abstract syntax tree compiler and native interop layer, allowing developers to map Rust types and functions into a scripting environment for bidirectional communication. The project serves as a framework for creating customizable domain-specific languages. It allows for the definition of custom operators, syntax, and restricted execution environments, enabling the creation of specialized languages with tailored functional sets. The engine covers a broad rang

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

vcmi is an open-source game engine for Heroes of Might and Magic III that recreates the gameplay, logic, and rendering of the original strategy game. It serves as a cross-platform game runtime supporting Windows, Linux, macOS, Android, and iOS, providing a turn-based strategy simulator for strategic world map navigation and tactical combat. The project is built as a moddable game framework, featuring a data-driven modding system and a sandboxed Lua scripting integration. These allow for the definition of custom gameplay logic, spell effects, and the addition of new factions, characters, and a

crun is a low-level container runtime that implements the Open Container Initiative specification for managing the lifecycle of isolated processes. It provides the core mechanisms for container creation, execution, and deletion, ensuring compatibility across platforms through standardized lifecycle management. The project distinguishes itself by offering a shared C library that allows container runtime operations to be embedded directly into other compiled applications. It further extends execution capabilities through specialized handlers that enable the deployment of containers within isola

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development. The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to redu

JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for resource-constrained devices. It serves as an embedded interpreter and IoT scripting runtime, enabling the execution of JavaScript code within native C applications on hardware with limited memory. The project differentiates itself through a focus on low-memory runtime management, utilizing bytecode precompilation and pre-compiled state snapshots to reduce startup time and memory overhead. It features a C-binding native bridge for bidirectional communication between native code and scripts,

mQuickjs is a compact JavaScript engine designed for memory-constrained devices, such as microcontrollers, requiring as little as 10 KB of RAM and 100 KB of ROM. It achieves this through a fixed-buffer memory allocation scheme that avoids system heap usage, a compacting tracing garbage collector that eliminates fragmentation, and a ROM-embedded standard library that reduces both memory footprint and startup time. The engine compiles JavaScript source into portable bytecode that can be stored in persistent memory and executed without reparsing, and it emulates IEEE 754 floating-point arithmetic

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

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

nanobind: tiny and efficient C++/Python bindings

A tiny JavaScript runtime

Bind C++ functions and classes into V8 JavaScript engine

:sparkles: Magical headers that make your C++ library accessible from JavaScript :rocket:

Cython is a compiler that translates Python code into C or C++ to create high-performance extension modules. It functions as a static typing optimizer and a C extension generator, allowing developers to declare C types within Python code to reduce interpreter overhead and increase execution speed. The project enables the wrapping of external C libraries to provide high-level interfaces to low-level system capabilities. It also serves as a native binary packager, capable of freezing scripts and their dependencies into standalone executable binaries for distribution. The system covers a broad

Embedded JavaScript engine for C/C++

Tools and libraries to glue C/C++ APIs to high-level languages

SWIG is a tool that generates wrapper code to expose C and C++ libraries to a wide range of higher-level programming languages. It reads annotated C/C++ header files and produces language-specific bindings from a single interface definition, supporting languages such as Python, Java, Ruby, C#, Perl, and many others. The generated wrapper code is free from the project's GPL license, allowing users to distribute it under their own terms. The tool handles modern C++ features including templates, namespaces, smart pointers, and constructs up to C++20 through specialized parsing and code generatio

Embedded Scripting Language Designed for C++

A foreign function interface for bash.

Library to build PHP extensions with C++

Boost.org python module

Import C++ files directly from Python!

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 Lua-based firmware environment for the ESP8266 WiFi chip, providing an embedded Lua interpreter and a development framework for WiFi SoC hardware. It functions as a C-based wrapper around the Espressif non-OS SDK, enabling the execution of asynchronous scripts to manage wireless communication and hardware peripherals. The environment integrates a SPIFFS flash filesystem for storing persistent scripts and data directly on non-volatile memory. To optimize limited hardware resources, the system utilizes execute-in-place flash execution, running read-only constants and instructi

Lite XL is a lightweight, cross-platform text editor built around a minimal C core that embeds a Lua interpreter, allowing the entire editor interface and functionality to be scripted and customized through Lua. It draws text and UI elements directly to a pixel buffer using a single-threaded event loop, bypassing heavyweight widget toolkits to keep the editor fast and responsive even on low-resource hardware. The editor distinguishes itself through its Lua-based plugin architecture and file-based configuration system, where settings, keybindings, and plugin metadata are stored as plain Lua fi

Rainmeter is a Windows desktop widget engine that renders customizable skins and interactive widgets directly on the desktop, supporting live data feeds and user interaction. It functions as a desktop customization platform and skin authoring framework, allowing users to create widgets by defining data sources and visual elements with full style and layout control. The engine includes a Lua scripting runtime for extending widget functionality with custom logic and data processing, and provides a plugin SDK with a C/C++ API for building native plugins that add new data sources or rendering capa