Open-source alternatives to J2objc

Vulture is a static analysis tool and linter designed to find unused variables, functions, and classes in Python source code. It operates as a dead code detector and unused code finder that scans source files to identify unreachable expressions and imports without executing the code. The tool employs a confidence-based heuristic scoring system to assign probability values to detections, helping to distinguish truly unused symbols from potential false positives. It further assists in pruning dead logic by sorting detected unused classes and functions by line count to prioritize the removal of

Grumpy is a native binary compiler that transforms Python source code into Go source code. By transpiling high-level scripts into a strongly typed intermediate representation, the system enables the creation of statically linked native binaries that operate independently of a traditional virtual machine interpreter. The project distinguishes itself by providing a comprehensive runtime library that replicates standard Python data structures and object behaviors. This emulation layer ensures that compiled code maintains functional parity with the original source environment while leveraging the

Dependency-cruiser is a JavaScript and TypeScript dependency analyzer and architectural linter. It serves as a static analysis tool for mapping, visualizing, and validating module relationships within a codebase without requiring code execution. The project is distinguished by its ability to enforce architectural boundaries through a rule-based system. It detects circular dependencies, identifies orphan modules and dead code, and validates dependency constraints using allowed and forbidden relationship rules. It also provides quantitative stability analysis by calculating afferent and efferen

Go is a statically typed, compiled programming language designed for building scalable, concurrent software. It provides a memory-safe execution environment that combines a high-performance runtime with a self-hosting compiler toolchain, enabling the creation of statically linked machine code binaries without external dependencies. The language is built around a structural type system that uses interfaces for polymorphism and a concurrency model based on lightweight, stack-based coroutines that communicate through channels. The language distinguishes itself through a runtime that features a c

Zen-C is a multi-target systems language and source-to-source compiler that translates high-level logic into human-readable GNU C or C11 code. It functions as a JIT-enabled programming language with an in-process compiler for real-time interactive code evaluation and testing. The project serves as a CUDA GPU kernel generator, mapping specialized syntax to CUDA C++ using device attributes to target graphics hardware. It acts as an interoperability layer capable of emitting compatible code for C++, Objective-C, and Lisp to bridge native system frameworks and libraries. The language includes an

The Java Development Kit is a comprehensive software development environment designed for compiling, debugging, and executing applications written in the Java programming language. It provides the core infrastructure necessary to transform human-readable source code into platform-independent bytecode and run those applications across diverse computing environments. At the center of this environment is the Java Virtual Machine, a runtime engine that executes compiled bytecode while managing memory and system resources. This architecture utilizes a stack-based virtual machine and a platform-agn

HIP is a C++ GPU kernel language and cross-platform runtime designed for writing portable high-performance compute applications. It provides a programming interface that allows a single source codebase to execute on both AMD and NVIDIA GPU architectures. The project functions as a compatibility layer that enables the conversion and migration of existing CUDA source code to run on AMD hardware. This is achieved through a syntax mapping that mirrors CUDA and a source-to-source translation process during compilation. The toolkit covers the broader surface of cross-platform GPGPU development, in

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

Verilator is a hardware simulation engine and toolchain that translates Verilog and SystemVerilog hardware description languages into optimized C++ or SystemC models. It functions as a compiler and transpiler, converting hardware designs into executable binaries to achieve high-speed simulation and integration into software environments. The project distinguishes itself by focusing on simulation acceleration through the generation of optimized C++ classes and cycle-accurate models. It provides a SystemVerilog linter for static analysis of hardware designs and a hardware coverage analyzer to t

Coconut is a functional programming language that compiles to Python. It functions as a source-to-source compiler, translating high-level functional syntax into compatible Python code to maintain runtime compatibility. The language introduces a logic system for pattern matching and destructuring complex data structures. It provides a mechanism for tail call optimization to prevent stack overflow errors during deep recursive function calls and employs a lazy evaluation engine to defer computations until results are explicitly required. The project includes support for algebraic data types, pi

Processing is a creative coding environment and Java graphics library designed for writing visual sketches that produce interactive 2D and 3D graphics and animations. It runs on the Java Virtual Machine, using an OpenGL-based hardware-accelerated rendering pipeline, and operates on a sketch-based execution model where programs run as continuous loops of setup and draw functions with event-driven input handling for keyboard, mouse, and window interactions. The environment distinguishes itself as a cross-platform sketch tool that runs visual programs unchanged on desktop, web, Android, and Rasp

This project is a comprehensive technical reference and programming cheatsheet for the Python language. It serves as a curated catalog of language features, syntax patterns, and standard library functions designed to help developers identify and apply correct coding patterns. The documentation covers a broad range of functional areas, including language fundamentals such as object-oriented structuring, functional logic, and list comprehensions. It also provides guidance on utilizing the standard library for data analysis, file management, networking, and concurrent execution. The reference e

GitBucket is a self-hosted Git hosting platform and forge designed for managing private repositories. Built with the Scala language, it provides a web interface for version control and is implemented as a server compatible with the GitHub API to ensure integration with existing third-party tools. The platform allows for customization of the version control environment through a plugin-based extension model, enabling the installation of third-party plugins to add specialized features. Its capability surface covers software project management via integrated issue trackers, pull requests, and w

FoldCraftLauncher is a Java game launcher for Android that provides a mobile runtime environment for executing various game versions and snapshots. It functions as an Android game environment that manages game instances, save files, and graphical renderer plugins. The project includes a Java runtime manager to bundle or import multiple Java versions, ensuring compatibility across different software releases. It features a virtual input mapper that simulates mouse and keyboard events by translating touch screen interactions and gyroscope data into desktop-style control signals. The system pro

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

AITemplate is an ahead-of-time deep learning compiler that translates PyTorch neural networks into standalone C++ source code. It functions as a PyTorch to C++ compiler and a GPU kernel fusion engine, producing self-contained executable binaries that run inference without requiring a Python interpreter or deep learning framework runtime. The project generates optimized CUDA and HIP C++ code specifically for NVIDIA TensorCores and AMD MatrixCores. It focuses on maximizing throughput for half-precision floating-point operations through a system that combines multiple neural network operators in

Porffor is an ahead-of-time compiler that converts JavaScript and TypeScript source code into native machine code or C binaries. It functions as a native binary generator and transpiler, producing standalone executable files that do not require a runtime or virtual machine. The project translates source code into C language files and WebAssembly binary formats. It includes a direct-to-binary pipeline for TypeScript, allowing for the generation of target executables without a separate transpilation step to JavaScript. The toolset also includes an interactive read-eval-print loop for real-time

Clojure is a general-purpose, functional programming language hosted on the Java Virtual Machine. It is a homoiconic S-expression language that represents programs as nested data structures, allowing code to be manipulated and evaluated as data. The project provides a framework for JVM interoperability, enabling the invocation of Java methods and integration with other JVM-based languages. It distinguishes itself through a persistent data structure library that uses bitmapped vector tries to manage immutable collections and a programmatic REPL for interactive software development and real-tim

This repository provides a collection of reference implementations for building mobile applications using the Kotlin Multiplatform framework. It serves as a practical guide for centralizing core application logic, data handling, and business rules into a single shared codebase while maintaining the ability to build native user interfaces for Android and iOS. The project demonstrates architectural patterns for managing state, persistence, and network synchronization across diverse mobile operating systems. By utilizing common source sets and platform-specific native interop, it enables develop

This project is a cross-platform development framework and application boilerplate designed to build mobile, desktop, and web applications from a single shared codebase. It functions as a React Native development tool, utilizing declarative components to render platform-specific user interfaces while maintaining consistent business logic across all supported environments. The framework distinguishes itself by centralizing core application rules and data management, ensuring identical functional results regardless of the target device. It employs a build-time file resolution system that allows

Nuitka is a compilation framework that translates Python source code into C, enabling the creation of standalone machine code binaries. By converting interpreted scripts into compiled executables, it removes the requirement for a language interpreter on the target machine and provides a mechanism for distributing Python applications as self-contained packages. The project distinguishes itself through advanced optimization techniques, including link-time code generation and profile-guided binary optimization, which improve execution speed by bypassing standard interpreted overhead. It manages

Hy is a Lisp implementation for Python that allows for writing Lisp syntax which compiles to Python bytecode. It operates as a Python-based Lisp dialect and S-expression language, providing full access to the Python standard library and ecosystem. The language focuses on macro-based metaprogramming, featuring an AST-walking macro system and reader macros that allow for custom syntax transformations and parsing rules. It enables the manipulation of the abstract syntax tree to extend language capabilities. The project includes a read-eval-print loop for interactive development and supports sta

Knip is a static analysis project cleaner and dead code analyzer for JavaScript and TypeScript projects. It identifies and removes unused files, dependencies, and exports to maintain a lean codebase and reduce bundle size. The tool functions as a monorepo dependency auditor, tracking exports and dependencies across multiple workspaces to find dead code in large multi-package projects. It specifically targets the removal of unused packages from project manifests and the deletion of unreferenced exports. Its capabilities cover dead code elimination, JavaScript dependency management, and TypeSc

vscode-recipes is a collection of configuration patterns and guides for setting up debuggers and runtime environments within VS Code. It provides standardized templates and blueprints to connect the editor to local, containerized, or serverless runtimes across a variety of programming languages and frameworks. The project focuses on coordinating simultaneous debugging sessions across client-side and server-side processes to trace logic through full-stack applications. It offers specific patterns for integrating language runtimes and orchestrating multi-language development setups within a sin

Airtest is a cross-platform UI automation framework that enables test scripts to run on Android, iOS, and Windows devices without platform-specific modifications. It combines image recognition with control hierarchy traversal to locate and interact with on-screen elements, supporting automation even when source code or UI metadata is unavailable. The framework provides a cloud-based test orchestrator that schedules test cases, manages device clusters, and generates detailed HTML reports with screen recordings after execution. It includes a command-line test runner for headless execution in CI

Reason is a strongly typed functional language and multi-target compiler designed to produce either JavaScript for web environments or native machine code for operating systems. It serves as an OCaml-compatible language that shares an abstract syntax tree with OCaml, providing a practical syntax for the OCaml ecosystem. The project functions as a type-safe frontend language, incorporating JSX support to build user interfaces through structural elements that translate into type-safe function calls. It enables deep integration with the JavaScript ecosystem, allowing the use of existing librarie

GopherJS is a cross-compiler toolchain that converts Go source code into JavaScript. It functions as a transpiler, enabling the execution of statically typed Go code within web browsers and other standard JavaScript runtime environments. The project provides a comprehensive implementation of the Go standard library, replacing system-level calls with browser-compatible APIs to maintain language semantics. It maps Go's memory allocation patterns and type definitions onto the host JavaScript engine, while utilizing source map generation to allow for debugging using original Go source files. By