Open-source alternatives to Cppimport

Duktape is an embeddable JavaScript engine and portable scripting runtime designed for integration into C and C++ applications. It functions as a lightweight ECMAScript runtime that provides a C-JavaScript bridge for exchanging data and invoking functions between native code and a script execution environment. The engine includes an ECMAScript bytecode compiler that allows for the serialization and caching of compiled functions to disk to reduce application startup time. It organizes script dependencies using a CommonJS-compliant module loader. The runtime covers a variety of capabilities in

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

A foreign function interface for bash.

Sol2 is a C++ Lua binding library that serves as a language interoperability layer for integrating Lua scripts into C++ applications. It acts as a scripting wrapper and API toolkit, enabling the execution of Lua code and the management of shared state within a native C++ environment. The library focuses on automated function and type mapping to bridge native C++ classes and complex data types with the Lua scripting engine. It provides mechanisms for bidirectional data exchange, allowing compiled logic and variables to be synchronized between the host application and the script runtime. The s

Boost.org python module

nanobind: tiny and efficient C++/Python bindings

JavaCPP is a JNI C++ bridge and foreign function interface that provides a binding generator, a native library loader, and a native memory manager. It automates the creation of Java wrappers around native C++ headers and shared libraries to enable interoperability between the two languages. The project features a C++ binding generator that parses header files to automatically produce the necessary glue code and interfaces for calling native functions. It includes a native library loader that locates and extracts platform-specific binaries from the classpath into a local cache for runtime exec

Embedded JavaScript engine for C/C++

Embedded Scripting Language Designed for C++

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

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

libffi is a foreign function interface library that enables calling functions written in other languages at runtime. It serves as a multi-architecture ABI wrapper and dynamic call frame generator, allowing the execution of external functions based on runtime descriptions of argument types and return values. The project provides a portable interface to handle diverse calling conventions across different hardware architectures and operating systems. It includes capabilities for executable closure allocation, which allows foreign code to trigger callbacks within a host language via jump tables s

Lua binding library for modern C++

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,

A lightweight, dependency-free library for binding Lua to C++

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

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

A language and an embedded JIT compiler

Bind C++ functions and classes into V8 JavaScript engine

A lightweight, dependency-free library for binding Lua to C++