Open-source alternatives to PyOxidizer

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

Swift Evolution serves as the central governance and design platform for the Swift programming language. It provides a structured, collaborative framework for tracking, discussing, and managing the formal proposals and technical goals that define the language's syntax, semantics, and core features. By maintaining a comprehensive collection of design documentation, the project ensures the long-term stability and consistency of the language as it matures. The repository acts as the primary hub for the language's evolution, coordinating community feedback and technical decisions through a transp

SciPy is a scientific computing library for Python that provides a comprehensive collection of mathematical algorithms and numerical tools for research and engineering. It functions as a high-performance numerical analysis framework, bridging high-level Python code with compiled C and Fortran routines to execute complex computations at hardware speeds. The library is built upon array-based data structures that utilize strided memory layouts to enable efficient data manipulation and slicing. By employing vectorized operation dispatch and linking to optimized hardware-specific linear algebra li

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

fbs is a Python desktop application packager and cross-platform application installer. It serves as a utility for compiling Python code into standalone executables and bundling application resources into platform-specific installation packages for various desktop environments. The project functions as a Qt Python GUI builder and resource bundler. It provides a system for creating desktop user interfaces using Python and the Qt framework while packaging external files and assets to be accessed during application runtime. Its broader capabilities cover desktop application packaging, cross-plat

Eel is a framework for creating desktop applications using a Python backend and a web-based frontend. It acts as a bidirectional bridge between Python and JavaScript, allowing developers to build graphical user interfaces with HTML and JavaScript that communicate with local system logic. The project facilitates two-way communication by enabling the exposure of Python functions to the browser and allowing the backend to trigger JavaScript functions. It uses a local server to render web interfaces as standalone desktop windows and provides tools to bundle the Python code and web assets into a s

auto-py-to-exe is a Python to EXE converter and standalone executable packager that provides a web-based graphical interface for PyInstaller. It transforms Python scripts into single binary files that run without requiring a local Python installation or external dependencies. The project functions as a JSON-based build automator, allowing users to save, load, and export complex packaging configurations via JSON files to ensure consistent and reproducible builds across different projects. The tool covers script-to-executable conversion, including the ability to bundle static assets and icons

Neon is a framework for writing high-performance native Node.js modules using the Rust programming language. It serves as a foreign function interface bridge and a toolchain for bootstrapping, compiling, and managing Rust-based extensions. The project provides a cross-language memory manager that handles buffers and object borrowing to ensure safe memory access between Rust and JavaScript. It enables the mapping of data types and function calls across the language boundary, allowing Rust functions to be exported to the script environment and JavaScript functions to be called from Rust. The f

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

Pex is a Python application bundler and isolated environment manager. It packages programs and their entire dependency trees into single executable files to simplify deployment across different environments. The tool functions as a portable executable creator by bundling multiple platform-specific distributions into a single file. This ensures that a program can run across different operating systems by mapping target platforms to compatible binary distributions. The system provides capabilities for dependency management and isolated execution. It can launch scripts or interpreters within te

node-ffi is a foreign function interface library for Node.js that enables calling functions from native C dynamic libraries without writing manual C++ bindings. It serves as a system for loading shared objects and DLLs into process memory, translating JavaScript values into binary representations, and executing external binaries at runtime. The project utilizes a wrapper around the libffi library to construct call frames and execute native functions with dynamic arguments. It distinguishes itself by providing a native memory manager for allocating raw pointers and a mapping system that connec

This project provides a full Python interpreter compiled to WebAssembly, enabling the execution of Python code and scientific libraries directly within web browsers and server-side environments. By bridging the gap between language runtimes, it allows developers to run computational tasks, manage packages, and perform data analysis in client-side environments without requiring a backend server. The platform distinguishes itself through a comprehensive foreign function interface that enables bidirectional data exchange, object proxying, and function calling between Python and JavaScript. It in

This project is a professional live video production suite designed for capturing, encoding, and broadcasting high-quality media. At its core, it features a real-time media processing engine that utilizes hardware acceleration to composite multiple audio and video sources with minimal latency. The application provides a centralized studio interface for managing complex scene transitions, layering visual sources through a hierarchical scene-graph engine, and streaming content to multiple platforms simultaneously. The software is built on a cross-platform abstraction layer that ensures consiste

CPython is the primary, community-maintained reference implementation of the Python programming language. It functions as a high-level, interpreted execution environment that compiles source code into platform-independent bytecode for processing by a stack-based virtual machine. The runtime manages memory through a combination of reference counting and generational cyclic garbage collection, while dynamic type dispatching determines object behavior at runtime based on metadata stored within object headers. The project is distinguished by its C-based architecture, which provides a stable forei

This project is a comprehensive guide for writing Neovim configurations and plugins using the Lua programming language. It serves as a manual for using the native Neovim Lua API to manage buffers, windows, and editor options. The guide focuses on the interoperability between Lua and Vimscript, providing instructions on how to execute Vimscript from Lua and call Lua functions from within Vimscript. It also provides a framework for plugin development, covering the organization of code into external modules and the creation of custom commands and key mappings. The documentation covers broader c

Natron is an open-source node-based video compositor and motion graphics software. It functions as a visual effects tool that combines images and video using a node graph and a linear color pipeline to create complex effects and set extensions. The software includes a 2D motion tracking suite for stabilizing footage and tracking pixel movement across frames. It is a Python-scriptable environment, allowing for custom automation and user interface extensions through an embedded Python interpreter. The platform provides a comprehensive range of compositing capabilities, including chroma keying,

This project is a comprehensive technical guide to advanced Go programming. It serves as a programming guide, technical reference, and textbook covering low-level optimization and distributed systems architecture. The resource provides detailed instructions on writing assembly instructions to optimize performance-critical code and managing C-Go interoperability to bridge C libraries with Go. It also functions as a manual for implementing remote procedure call mechanisms and creating custom plugins for the Protocol Buffers compiler. The material covers high-level capabilities including the de

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

NGINX Unit is an open-source application server designed to natively execute code across multiple programming language runtimes and WebAssembly within a single process. It serves as a multi-language application server that can run applications written in Go, Java, Node.js, Perl, PHP, Python, Ruby, and WebAssembly side by side, without requiring separate runtime environments for each language. The server distinguishes itself through a RESTful JSON control API that enables dynamic, zero-downtime configuration changes without restarting the server. It combines event-driven asynchronous I/O with

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

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

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

This project provides Rust bindings for the Dear ImGui library, enabling the creation of high-performance graphical user interfaces using an immediate-mode paradigm. By defining interface elements directly within the application render loop, it eliminates the need for persistent object hierarchies, allowing for rapid prototyping and dynamic visual updates. The library distinguishes itself by wrapping complex native function signatures in type-safe builders, which improves developer ergonomics while maintaining the performance characteristics of the underlying C++ implementation. It utilizes a

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

gdext provides a set of language bindings for writing high-performance native game logic in Rust for the Godot 4 engine. It serves as a framework for creating native engine extensions and custom classes via the GDExtension library, allowing developers to extend core engine functionality without recompiling the engine source code. The project includes a dedicated Rust WebAssembly toolchain to compile native logic into modules for execution in web browsers. This system supports WebAssembly-compatible compilation with specific configurations for web threading and module debugging. The toolkit c

cuda-python provides low-level Python bindings for the CUDA Driver and Runtime APIs. It serves as a programmatic wrapper for controlling device memory, managing hardware toolchains, and orchestrating execution graphs on NVIDIA GPUs, allowing for the compilation and launching of parallel kernels directly from Python. The project enables the development of SIMT kernels and the execution of mathematical algorithms on device memory. It integrates pre-compiled bytecode as custom operators and interfaces with accelerated device libraries to access low-level hardware functions without leaving the la