Ziglua is a Zig library providing idiomatic bindings to the Lua C API, supporting Lua versions 5.1 through 5.5, LuaJIT, and Luau. It compiles the chosen Lua runtime from source at build time and exposes nearly the entire C API through a safe, Zig-native interface. The library leverages Zig's features such as slices, enums, optionals, and error unions to reduce memory unsafety and improve ergonomics compared to raw C bindings. It also includes a set of higher-level utilities like `wrap` for converting Zig functions into Lua-callable closures, `Buffer` for efficient string construction, and `toAny`/`pushAny` for automatic Lua–Zig serialization of common types. Architecturally, Ziglua is a single Zig module (`zlua`) that can be imported by any Zig project. The build system (`build.zig`) handles fetching the Lua source code, applying necessary patches, and compiling it as a static or shared library. Bindings are generated via Zig's `translate-c` tool from the Lua C headers, with additional manual Zig wrappers in `src/lib.zig`. The project is well-tested across multiple platforms (Linux, macOS, Windows) and supports Lua version selection, allocator integration, and both embedded and shared-library usage. Ziglua is actively maintained against Zig's master branch, with documented API and a clear changelog.
Rustler is a Rust library that provides safe and idiomatic bindings for writing Erlang Native Implemented Functions (NIFs). It replaces error-prone C NIFs with Rust code that cannot crash the BEAM virtual machine. The core library offers safe wrappers for the Erlang NIF API, including term construction and decoding (Encoder/Decoder traits), resource management for Rust-owned data, thread spawning with safe message passing, and an experimental serde integration for generic serialization. A companion proc-macro crate (rustler_codegen) automatically generates Encoder/Decoder implementations for user-defined types (structs, maps, tuples, records, enums) and handles NIF registration via the #[nif] attribute and init! macro. The project also includes an Elixir Mix compiler plugin (rustler_mix) that automates compilation of Rust NIFs within Elixir projects. Rustler supports multiple Erlang/OTP versions (NIF 2.14 through 2.18) via version-conditional FFI headers and dynamic symbol loading. It is widely adopted in the Elixir ecosystem for performance-critical code paths.
vkbind is a Vulkan API loader and code generator that creates a single header file containing all Vulkan API definitions and functions for dynamically loading Vulkan functions. It parses the official Vulkan XML specifications (vk.xml and video.xml) to generate a comprehensive C header that eliminates the need for the official Vulkan SDK. The generated header includes type definitions, enumerants, function prototypes, and loader functions like vkInit(), vkInitInstanceAPI(), and vkBindAPI() for accessing Vulkan functionality across different platforms.
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.