Open-source alternatives to Java Native Access Jna

This project is a collection of official plugin packages and a native integration library designed to provide a consistent interface for accessing hardware and software functionality across different mobile and desktop platforms. It serves as a native platform bridge, enabling cross-platform applications to invoke native code and manage operating system dependencies. The project utilizes a federated plugin architecture, splitting plugins into common interfaces and separate platform implementations to allow for independent development and extension. It further supports native integration throu

Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

Torch7 is a scientific computing environment and tensor computation library used for deep learning research and numerical analysis. It functions as a Lua-based framework for training neural networks and learning agents, providing a toolkit for implementing architectures and training through reinforcement learning algorithms. The project is distinguished by its tight integration with C, utilizing a binding layer to map high-level scripting to low-level C structures for direct memory access. It supports hardware-accelerated computation by offloading linear algebra and convolution operations to

This project provides a header-only C++ wrapper for the Node-API, serving as a framework for building high-performance native addons for Node.js. It acts as a bridge between C++ and JavaScript, offering an object-oriented interface that simplifies the creation of compiled extensions while managing the complexities of the language boundary. The library distinguishes itself by providing type-safe abstractions for data marshalling and memory management, ensuring that native and script-side objects are tracked and reclaimed correctly. It includes mechanisms for coordinating asynchronous tasks bet

pywin32 is a collection of Python extensions that serve as a wrapper for the native Windows API, enabling the invocation of operating system functions to manage low-level system resources and hardware. It provides a core library for interacting with Component Object Model objects to automate native desktop applications, a framework for constructing native Windows GUI applications, and an interface for registering and running Python scripts as background system services. The project distinguishes itself by providing deep integration with the Windows environment, including the ability to bind P

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

The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++ native code into Android applications. This repository serves as a practical guide for developers utilizing the Android Native Development Kit to implement performance-critical application components that require direct hardware access and low-level system interaction. The project highlights the use of the Java Native Interface to bridge managed code with native modules, enabling cross-language function calls and efficient data exchange. It demonstrates how to manage native act

xHook is a low-level instrumenter and hooking library for Android ELF binaries. It functions as a framework for intercepting native symbols and redirecting function calls by modifying the procedure linkage table. The tool utilizes regular expressions to filter specific binary files and symbols for interception. It enables the redirection of native calls toward custom function implementations without altering the original binary files. The framework covers dynamic symbol resolution, ELF table modification, and security analysis of native libraries. It also includes stability mechanisms that u

Rustler is a native function wrapper and foreign function interface that enables the development of high-performance extensions for the BEAM virtual machine. It serves as a bridge for writing native functions in Rust that can be called from Erlang environments. The project focuses on maintaining memory safety to prevent system crashes and memory corruption when executing compiled code. It achieves this by wrapping native calls in safe abstractions and applying Rust's ownership and borrowing rules to the management of external memory and structured data objects. The library provides mechanism

JavaCV provides a Java-based interface for native computer vision and video processing libraries. It functions as a wrapper for native vision libraries, allowing Java applications to perform image analysis, object detection, and video stream processing. The project integrates comprehensive computer vision capabilities, including facial recognition, image segmentation, and optical flow analysis for motion tracking. It also provides tools for hardware geometry calibration and projector-camera alignment to ensure accurate spatial representation. The system covers high-performance media renderin

Darwinkit is a Cgo interop layer and library of native bindings that allows Go applications to call Apple frameworks and system APIs. It functions as a bridge between the Go runtime and native C-compatible symbols to facilitate macOS system programming and native application development. The project includes an Objective-C binding generator that scans system symbol databases to produce Go source code and constants. This tool enables the inspection of framework symbols and the management of binding modules to maintain current interfaces with native frameworks. The library provides a memory ma

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

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

Rust-bindgen is a build-time foreign function interface binding generator and C header parser designed to automate cross-language interoperability. It functions as a tool to bridge Rust with C, C++, and Objective-C libraries by producing platform-specific declarations during the compilation process. The project distinguishes itself through its ability to handle complex C-family language constructs, including C++ inheritance and methods, as well as Objective-C classes and protocols. It ensures binary compatibility across different architectures by calculating target-aware memory layouts and va

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface. What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performa

Napajs is an embeddable JavaScript engine and multi-threaded runtime designed to be integrated directly into other software applications as a component. It serves as a parallel computation framework that allows JavaScript code to execute across multiple threads, bypassing the standard single-threaded event loop limitation to handle CPU-intensive tasks. The runtime is distinguished by its ability to load and execute modules from the NPM ecosystem and its pluggable execution environment. This architecture allows for custom implementations of memory allocation, system logging, and performance me

This project is a compatibility layer and abstraction library for building native C++ addons for Node.js. It provides a consistent C++ API that allows a single codebase to compile against multiple versions of the V8 JavaScript engine by hiding version-specific differences behind macros and inline functions. The toolkit differentiates itself through specialized wrappers and managers, including a monadic wrapper for handles to avoid explicit null checks, a persistent reference manager for objects that must survive handle scope disposal, and a buffer abstraction API for version-compatible memory

Geode is a game modification SDK and mod loader for Geometry Dash. It functions as a hooking engine and UI framework that allows for the injection of dynamic libraries to alter game behavior and add new features. The toolkit distinguishes itself through a centralized mod compatibility manager and hook registry that tracks active modifications to prevent logic conflicts and application crashes. It utilizes a trampoline-based hooking engine to redirect game function calls while preserving native call stacks, alongside a dedicated UI framework for rendering custom popups and interface components

bflat is a native compiler and ahead-of-time binary generator for C#. It transforms source code into self-contained native executables and machine code that run without requiring a separate runtime environment. The project features a cross-platform native toolchain capable of generating binaries for multiple operating systems and architectures from a single environment. It includes a mechanism for exporting C# logic as shared native libraries via a foreign function interface for integration with other programming languages. To support resource-constrained environments, it provides a binary o

ChezScheme is a compiler and runtime environment for the Scheme programming language that transforms source code into optimized machine binaries. It serves as a high-performance implementation of the language, producing executable machine code for execution on physical hardware. The project features a native machine code compiler, a read-eval-print loop for executing and editing multi-line expressions in real time via a shell, and a generational garbage collected runtime for automatic memory management. It also includes a foreign function interface for integrating external C libraries and lan

The Rust RFCs repository is the formal home for the Rust language evolution process, housing the structured design documents and community review mechanisms that govern changes to the Rust programming language, its compiler, and its standard library. It defines the complete lifecycle for proposing, discussing, and implementing substantial changes through RFC documents, from initial submission and community feedback through final comment periods and sub-team sign-offs. The repository codifies the governance and collaboration processes that shape Rust's development, including mechanisms for com

Odin is a compiled, statically typed systems programming language designed for high-performance software development. It focuses on pragmatic low-level memory control, providing a toolset for manual memory management and precise control over hardware utilization. The language is distinguished by its flexible memory model, which includes custom allocators and precise data layout capabilities to optimize resource usage. It features a comprehensive foreign function interface for importing assembly files and linking with external libraries using configurable calling conventions. The type system

OffensiveNim is a red teaming framework and post-exploitation toolkit developed in Nim. It provides a collection of low-level primitives and a Windows API wrapper designed for offensive security operations, including malware development and shellcode loading. The project focuses on evasion and obfuscation through techniques such as API unhooking, direct system calls, and anti-debugging mechanisms. It features diverse payload delivery methods, including reflective binary loading, the execution of .NET assemblies via CLR hosting, and various shellcode injection techniques using fibers, COM obje

This project provides a comprehensive set of language bindings that enable direct interaction with the Windows API and Windows Runtime components from Rust. It serves as a native interface for systems programming, allowing developers to execute system functions and access operating system services while maintaining memory safety and idiomatic language constructs. The library utilizes metadata-driven code generation to map the entire Windows API surface area into type-safe wrappers. By employing a zero-cost abstraction layer, it ensures that these high-level calls compile to the same machine i

The Arm Architecture Binary Interface Specification is a technical standard that defines the rules for procedure calls, object file formats, and exception handling. It serves as a foundational framework for ensuring binary-level compatibility between software components and operating systems across diverse Arm processor implementations. This specification establishes the technical requirements for how software interacts with hardware at the binary level. By standardizing register-based calling conventions, stack-frame layouts, and data-type alignment rules, it enables consistent behavior for

NativeScript is a cross-platform mobile development framework that enables the creation of native iOS and Android applications using JavaScript or TypeScript. It provides a direct bridge to native platform APIs, allowing developers to invoke native classes, methods, and properties directly from script code while maintaining full access to underlying mobile operating system features. The framework distinguishes itself through its direct native UI rendering, which maps declarative markup components to actual platform-native widgets rather than web-based views. This architecture is supported by

LibGDX is a Java-based framework designed for cross-platform game development, enabling the creation and deployment of 2D and 3D games across desktop, mobile, and web environments from a single codebase. It functions as a comprehensive library that abstracts hardware-accelerated graphics, audio, input, and file system access, providing a unified interface for developers to manage game logic and application lifecycles. The framework distinguishes itself through a high-performance architecture that prioritizes efficiency and native interoperability. It utilizes a batch-oriented graphics pipelin