Source compiler

LLVM is a modular compiler infrastructure and framework consisting of a collection of reusable libraries used to build language front-ends and optimization tools. It functions as a low-level virtual machine that provides an intermediate representation and optimization pipeline to enable language-agnostic code generation. The project provides a toolkit for just-in-time compilation, translating intermediate representations into machine code at runtime for immediate execution. Its modular design allows developers to create custom language front-ends and high-performance runtime environments acro

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

Grin is a compiler infrastructure designed for the translation and optimization of high-level functional languages. It functions as a graph-reduction compiler, transforming source code into a standardized intermediate representation that facilitates whole-program analysis and efficient execution across diverse hardware architectures. The project distinguishes itself through a modular backend infrastructure that separates intermediate representation management from target-specific code generation. By utilizing graph-based transformations, the system performs advanced optimizations such as valu

Kotlin is a statically typed, general-purpose programming language designed for type safety and concise syntax. It functions as a cross-platform development toolkit that enables the sharing of business logic across mobile, web, and server-side environments by compiling a unified intermediate representation into platform-specific machine code, bytecode, or source code. The project distinguishes itself through a multi-target build orchestration model that manages complex compilation units and hierarchical source sets. Developers can define common interface logic that is satisfied by platform-sp

MoonBit is a programming language compiler and build system designed to translate source code into high-performance binaries for web, browser, and native environments. It provides a unified toolchain that manages the entire development lifecycle, from source code compilation and dependency management to the final bundling of applications. The platform distinguishes itself through a modular architecture that enables cross-environment logic sharing, allowing developers to maintain a single codebase that targets both WebAssembly and native machine code. By utilizing a strongly-typed intermediate

Wenyan is an esoteric programming language that enables the composition of functional logic using the grammar and vocabulary of classical Chinese literature. It functions as a source-to-source compiler, translating literary scripts into standard high-level programming languages such as JavaScript, Python, and Ruby to facilitate execution across diverse computing environments. The project distinguishes itself by bridging the gap between ancient linguistic structures and modern computational tasks. It utilizes a specialized transpilation process that maps classical grammatical particles and voc

The project is a modular compiler infrastructure framework designed for building programming language toolchains, frontends, and backends. It provides a comprehensive suite of reusable libraries and tools that enable developers to transform source code into efficient native executables across diverse hardware architectures and operating systems. At its core, the system utilizes a language-agnostic intermediate representation bitcode, which serves as a unified format for code analysis, optimization, and machine-specific code generation. What distinguishes this framework is its highly decoupled

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

Janino is a lightweight Java compiler and scripting engine designed to transform source code into executable bytecode directly within the application heap. It functions as a runtime compiler and class loading library, enabling the dynamic definition and execution of Java classes, methods, and expressions without requiring a full application restart. The project distinguishes itself through its ability to perform in-memory compilation and recursive descent parsing, which allows for the resolution of complex dependencies and circular references during the translation process. It provides a fram

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

esbuild is a high-performance JavaScript bundler and transpiler designed to transform modern web assets into production-ready code. Built with a focus on speed, it utilizes a concurrent execution model to perform parsing, linking, and code generation across multiple CPU cores. The engine handles a wide range of tasks, including TypeScript compilation, JSX transformation, and CSS bundling, while maintaining a consistent build process across diverse environments. What distinguishes the project is its architecture, which leverages memory-mapped file processing and a single-pass transformation st

sqlglot is a SQL parser and transpiler that represents queries as abstract syntax trees to enable structural analysis, modification, and semantic transformation. It functions as a dialect translator and query optimizer, converting SQL code between different database engines and simplifying syntax trees through rule-based normalization. The project provides a framework for defining custom SQL dialects by overriding tokenizers, parsers, and generators. It includes a lineage analyzer to track data flow from source tables through complex queries to identify the origin of specific columns. Additi

V is a statically typed, compiled programming language designed for high-performance systems development. It prioritizes memory safety and execution speed by enforcing strict type checking and immutable defaults, while generating native machine code for multiple hardware architectures. The language is built around an integrated toolchain that includes a compiler, package manager, formatter, and testing utilities within a single executable, facilitating rapid development cycles. What distinguishes V is its focus on developer productivity and interoperability. It provides a direct interface for

Binaryen is a WebAssembly compiler toolchain and optimizer designed to transform, validate, and shrink binary modules. It provides a comprehensive intermediate representation framework that converts binary code into a single-assignment form to enable advanced program analysis and code transformation. The project includes a specialized transformation engine that applies iterative optimization passes to increase execution speed and reduce binary size. Additionally, it functions as a transpiler that translates WebAssembly binary modules into executable JavaScript for environments that lack nativ

Zig is a general-purpose systems programming language designed for high-performance applications that require manual memory management and direct control over hardware resources. It prioritizes predictable execution by enforcing explicit control flow and requiring functions to accept explicit memory allocators, ensuring that all heap operations and logic paths remain visible to the developer. The language distinguishes itself through a powerful compile-time metaprogramming engine that allows for arbitrary code execution during the build process, enabling advanced reflection and the generation

Taichi is a domain-specific programming language embedded in Python designed for high-performance numerical computing and computer graphics. It functions as a parallel compiler that translates high-level mathematical expressions into optimized machine instructions, enabling developers to write compute-intensive algorithms that execute across diverse hardware architectures, including CPUs, GPUs, and specialized accelerators. The project distinguishes itself through a hardware-agnostic execution layer that maps parallel operations to multiple backends such as CUDA, Metal, and Vulkan. By utilizi

Swift is a high-performance, general-purpose programming language designed for safety and speed. It features a modular compiler front-end that transforms source code into optimized machine binaries, utilizing a value-oriented type system that prioritizes predictable state management through value and reference types. The language is built on a task-based concurrency model that schedules asynchronous operations across multicore hardware to ensure data race safety. The project distinguishes itself through a native, bi-directional interoperability mechanism that allows for direct integration wit

OCaml is a strongly typed functional language featuring a sophisticated type system and a focus on safety and expressiveness. It provides a comprehensive compiling toolchain that transforms source code into either portable bytecode or high-performance native binaries. The project is distinguished by a shared memory parallel runtime that executes computations across multiple processor cores using domains, and an algebraic effect system for managing side effects and control flow through execution context handlers. It also includes a dedicated parser generator to automatically create lexers and

Haste-compiler is a source-to-source compiler and web framework that translates Haskell source code into JavaScript programs for execution in web browsers and server environments. It enables the creation of unified web applications from a single type-safe codebase, automatically generating communicating client and server binaries while preserving static type guarantees across tiers. The system translates high-level code through an existing compiler infrastructure paired with custom code generators, supported by an AST-based optimization and minification pipeline for producing lean deployment

Tiramisu is a polyhedral C++ compiler framework designed to express and optimize data-parallel algorithms for diverse hardware accelerators. It provides a programming interface that allows developers to define mathematical expressions, manage loop iteration spaces, and organize functions targeting heterogeneous architectures. The system features an advanced compilation infrastructure that abstracts computations into a hardware-agnostic intermediate representation before lowering them into native machine code or hardware configuration bitstreams. It calculates exact data flow dependencies thro

Clash is a functional hardware compiler and hardware description language compiler that translates strongly typed functional programs written in Haskell into synthesizable VHDL, Verilog, and SystemVerilog code. It serves as a development tool allowing digital designers to write hardware descriptions in functional languages and compile them directly to FPGA targets and physical netlists. The compilation infrastructure covers structural hardware compilation, including graph-based code normalization, functional language translation, and netlist generation. It features type-level clock domain saf

Claudes C Compiler is a self-contained C compiler toolchain that parses source code, optimizes intermediate representations, and generates machine code without relying on external assemblers, linkers, or toolchain dependencies. It translates C source files directly into standalone executable binaries, object files, or assembly text across multiple hardware architectures. The project provides built-in assembly and linking capabilities, processing architecture-specific assembly text, encoding instructions, combining object files and static archives, resolving symbols, applying relocations, and

Compiler Explorer is an online tool and analysis platform used to translate source code into assembly in real time. It functions as a cross-compiler analysis tool, allowing users to examine how various compilers and versions translate the same source code into machine code to analyze optimizations and generation patterns. The platform supports low-level language debugging and the comparison of assembly output across different compiler toolchains. It also provides a self-hosted environment option for users who need to run private deployments with custom binaries or operate within secure offlin

Closure Compiler is a JavaScript build utility designed to transform, optimize, and validate source code for production environments. It functions as a minifier and transpiler, converting modern ECMAScript syntax into older, widely compatible versions to ensure reliable execution across diverse browsers. The tool distinguishes itself through a multi-pass optimization pipeline that performs complex refactoring, such as constant folding, function inlining, and variable renaming. It utilizes a static type inference engine to detect potential runtime errors and enforce type safety without requiri

This project is an educational compiler implementation and architecture demo. It serves as a small-scale C-style language compiler designed to demonstrate the fundamental stages of transforming source code into executable machine instructions. The codebase functions as a tool for compiler architecture education and design prototyping. It illustrates the process of building an educational language implementation to help users understand the mechanics of parsing and code generation. The implementation covers the primary stages of a compiler pipeline, including regular expression tokenization,

This project is a functional programming compiler and JavaScript transpiler that transforms a statically typed language into optimized JavaScript for web browsers. It serves as a frontend architecture framework, providing a static type system and a package manager that enforces semantic versioning. The compiler uses a type-checking engine with automatic type inference to prevent runtime errors and guide code refactoring. It implements a structural pattern for managing application state and rendering user interfaces through a virtual DOM, utilizing immutable data and purity-based state transit

F# to JavaScript, TypeScript, Python, Rust, Erlang and Dart Compiler

This project is a JavaScript optimizer, minifier, module bundler, transpiler, and static analysis tool. It provides a compilation pipeline designed to shrink file sizes and improve runtime performance. The system utilizes a multi-pass compilation process to perform dead code elimination, global name mangling, and static type inference. It identifies unreachable functions and unused variables to reduce the final output size and detects potential runtime errors without executing the code. The tool manages assets through dependency resolution, code chunking, and bundle management. It ensures co

Taco is a sparse tensor algebra compiler that translates high-level tensor index expressions into optimized machine code. It functions as a numerical code generator, producing specialized C kernels designed to execute complex multidimensional array operations efficiently on both CPU and GPU hardware. The project distinguishes itself by allowing users to define custom tensor storage layouts by composing dimension-level formats, such as dense or compressed structures, to match the specific sparsity patterns of their datasets. By analyzing the mathematical structure of tensor operations at compi

Ultra Tiny Compiler

The Papyrus compiler is based on the V language compiler, for use with Skymp VM (Not tested in Skyrim)

Traceur is a JavaScript syntax transpiler that transforms modern and next-generation language features into compatible versions for older runtime environments. It functions as a compiler that translates proposed language standards and upcoming syntax into current versions to maintain cross-engine compatibility. The project operates as an asynchronous code transformer, converting async functions and generators into promise-based state machines. It includes a functional tail-call optimizer that wraps recursive functions in trampolines to prevent stack overflows and an ECMAScript polyfill engine