88 projects
Rust
Rust is a systems programming language focused on safety, concurrency, and performance. It provides memory safety without garbage collection, thread safety without data races, and abstractions with zero cost.
25,936
6,349
$143M
ASP.NET Core
ASP.NET Core is a cross-platform, high-performance, open-source framework for building modern, cloud-enabled, Internet-connected applications. It enables developers to create web apps, APIs, microservices, and real-time web applications that can run on Windows, macOS, and Linux.
21,358
3,011
$80M
LLVM
LLVM is a collection of modular and reusable compiler and toolchain technologies used for developing compiler front ends and back ends. The project includes a modern, LLVM intermediate representation (IR), a suite of optimizers, code generators, and various tools for building complete compiler systems.
20,719
2,860
$840M
Roslyn
Roslyn is the open-source .NET Compiler Platform that provides rich code analysis APIs and compiler services for C# and Visual Basic languages. It includes the compiler infrastructure, source code analysis tools, and APIs for code generation and manipulation.
9,947
1,633
$303M
Ferrocene
Ferrocene is a commercial-grade Rust compiler and toolchain designed for safety-critical systems and industries requiring formal verification and certification. It aims to bring Rust's memory safety and modern development features to regulated domains like automotive, aerospace, and medical devices.
9,743
1,485
$152M
ClangIR
ClangIR appears to be a project related to LLVM's Clang compiler infrastructure, likely focused on intermediate representation (IR) functionality within the Clang C/C++ frontend
8,142
564
$829M
ONNX
ONNX is an open format built to represent machine learning models. ONNX defines a common set of operators - the building blocks of machine learning and deep learning models - and a common file format to enable AI developers to use models with a variety of frameworks, tools, runtimes, and compilers.
8,037
995
$51M
LLVM-MOS
LLVM-MOS is a project that provides a complete LLVM-based toolchain for MOS 6502 processors, enabling modern C/C++ development for 6502-based systems like the Commodore 64, NES, and other vintage computers and consoles
8,028
571
$836M
LLVM AIE
Fork of LLVM to support AMD AIEngine processors
7,854
575
$769M
OpenCilk
Monorepo for the OpenCilk compiler. Forked from llvm/llvm-project and based on Tapir/LLVM.
7,546
523
$798M
Zig
Zig is a general-purpose programming language and toolchain designed for robustness, optimality, and maintainability. It provides low-level control with compile-time features, cross-compilation capabilities, and a focus on practical systems programming.
6,662
1,635
$165M
Emscripten
Emscripten is a complete compiler toolchain that allows compiling C and C++ code into WebAssembly and JavaScript for running on the web. It enables developers to port native applications and libraries to run in web browsers while maintaining high performance.
5,571
1,378
$69M
Swift
Swift is a powerful and intuitive programming language for iOS, macOS, watchOS, and tvOS development. Created by Apple, it offers modern features like type inference, optionals, and protocol-oriented programming while maintaining performance and safety.
5,540
1,135
$124M
LLVM-MSVC
[WIP] A forked version of LLVM-18 that prioritizes MSVC compatibility. This version is tailored for Windows users.
5,287
387
$297M
GCC Rust
GCC Rust (gccrs) is a project to add the Rust programming language as a first-class supported language to the GNU Compiler Collection (GCC). It aims to provide an alternative implementation of the Rust compiler that integrates with GCC's infrastructure.
4,499
409
$557M
GCC
GCC (GNU Compiler Collection) is a widely-used compiler system that supports multiple programming languages including C, C++, Objective-C, Fortran, Ada, Go, and D. It provides a collection of compilers, libraries, and tools for building and optimizing software across different platforms and architectures.
4,340
427
$1.1B
V
V is a statically typed compiled programming language designed for building maintainable software, with a focus on performance, safety, and simplicity. It combines the performance of C with the safety of Rust and the simplicity of Go, featuring fast compilation, zero dependencies, and automatic memory management.
4,175
907
$32M
GraalVM
GraalVM is a high-performance runtime that provides significant improvements in application performance and efficiency. It includes a native image compiler for ahead-of-time compilation of Java applications into standalone native executables, a polyglot virtual machine that can run multiple programming languages efficiently, and tools for optimizing and debugging applications.
3,970
959
$85M
SBT
SBT (Simple Build Tool) is a build tool for Scala and Java projects that emphasizes dependency management, task automation, and incremental compilation. It uses Scala for its build definition files, allowing for type-safe and flexible build configurations.
3,800
1,115
$3.8M
Cinder
Cinder is Meta's internal performance-oriented production version of CPython.
3,651
700
$87M
Numba
Numba is a Just-In-Time (JIT) compiler that translates a subset of Python and NumPy code into fast machine code, specializing in numerical computing and scientific applications. It enables Python functions to be compiled to native machine instructions, significantly improving performance for computationally intensive operations.
3,634
873
$9.9M
Apache TVM
Apache TVM is an open source machine learning compiler framework for CPUs, GPUs, and machine learning accelerators. It aims to enable machine learning engineers to optimize and run computations efficiently on any hardware backend.
3,271
388
$24M
rocMLIR
MLIR for AMD GPUs is a Linux Foundation project implementing Multi-Level Intermediate Representation compiler infrastructure specifically optimized for AMD graphics processing units, enhancing machine learning workload performance and development efficiency.
2,961
232
$833M
Triton
Triton is a programming language and compiler framework designed for GPU programming, focusing on tensor computations and machine learning workloads. It enables developers to write high-performance code for GPU acceleration with Python-like syntax while providing low-level hardware control.
2,931
529
$7.7M
Compiler Explorer
Compiler Explorer is an interactive web-based tool that allows users to explore how different compilers transform source code into assembly language. It supports multiple programming languages and compiler versions, enabling real-time compilation and comparison of assembly output.
2,922
724
$118M
Scala 3 (Dotty)
Scala 3 (formerly Dotty) is the official next-generation compiler and language implementation for Scala, featuring significant improvements to the type system, syntax, and metaprogramming capabilities while maintaining compatibility with Scala 2.x
2,786
626
$25M
Google Closure Compiler
A JavaScript compiler that reduces code size through optimization and minification, rewriting and analyzing JavaScript programs to make them more efficient while preserving functionality
2,520
429
$24M
Nuitka
Nuitka is a Python compiler that translates Python code into standalone executables. It compiles Python applications into binary programs that can run without requiring a Python installation, offering improved performance and protection of source code. The compiler supports most Python features and standard library modules, making it suitable for both small scripts and large applications.
2,369
430
$22M
Kotlin Programming Language
Kotlin is a modern, cross-platform programming language developed by JetBrains that runs on the JVM and can be compiled to JavaScript and native code. It offers full interoperability with Java while providing additional features like null safety, coroutines, and more concise syntax.
2,328
376
$264M
F#
F# is a functional-first programming language that runs on .NET. It is an open-source, cross-platform language that supports functional, imperative, and object-oriented programming paradigms. The project includes the F# compiler, core library implementation, and language tools.
2,163
436
$32M
P4 Fund
The P4 Fund supports the P4 Project.
2,096
267
$706M
Odin Programming Language
Odin is a fast, concise, readable, pragmatic and performant systems programming language with manual memory management. It is designed to be an alternative to C with modern features like array programming, type inference, multiple return values, and memory management through allocators.
1,872
219
$26M
Scala 2
Scala 2 is the second major version of the Scala programming language, a statically-typed language that combines object-oriented and functional programming features while running on the Java Virtual Machine (JVM). It represents the mainstream implementation of Scala that has been widely used in production environments.
1,751
471
$18M
XLA
XLA (Accelerated Linear Algebra) is a compiler and runtime system for machine learning that optimizes and executes computational graphs across different hardware platforms. It provides hardware abstraction and optimization capabilities for deep learning frameworks, enabling efficient execution of ML models on various accelerators like GPUs and TPUs.
1,700
204
$56M
OCaml
OCaml is a general-purpose, industrial-strength programming language with an emphasis on expressiveness and safety. It is the main implementation of the Caml language, featuring a powerful type system with type inference, pattern matching, and support for functional, imperative, and object-oriented programming paradigms.
1,556
384
$18M
GNU Binutils and GDB
GNU Binutils and GDB is a collection of binary tools and debugger software. Binutils includes utilities for manipulating object files, while GDB (GNU Debugger) provides debugging capabilities for programs written in various programming languages. Together they form essential development tools for working with compiled code.
1,436
248
$304M
glslang
glslang is a language front-end and validator for GLSL/ESSL (OpenGL Shading Language and OpenGL ES Shading Language), and a SPIR-V generator. It serves as a reference compiler for these shading languages and is used in the OpenGL and Vulkan ecosystems.
1,408
269
$6.1M
Verilator
Verilator is an open-source tool that converts Verilog and SystemVerilog hardware description language (HDL) code into C++ or SystemC for simulation and verification. It performs lint checks, generates executable models, and is widely used in digital design and hardware verification workflows.
1,400
232
$19M
Gleam
Gleam is a statically typed functional programming language designed for building scalable concurrent systems. It compiles to Erlang and runs on the BEAM virtual machine, offering type safety, immutability, and seamless interoperability with Erlang and Elixir ecosystems.
1,302
402
$6.8M
V8 JavaScript Engine
V8 is Google's high-performance open source JavaScript and WebAssembly engine, written in C++. It implements ECMAScript and WebAssembly, and runs in Google Chrome, Node.js, and other applications. V8 compiles JavaScript directly to native machine code before executing it, using advanced optimization techniques to deliver high runtime performance.
1,264
122
$127M
LDC - LLVM-based D Compiler
LDC is an LLVM-based compiler for the D programming language that aims to produce efficient native code by leveraging LLVM's optimization and code generation capabilities. It serves as an alternative D compiler implementation that is compatible with DMD, the reference D compiler.
1,197
232
$28M
Halide
Halide is a domain-specific language and compiler for high-performance image processing and array processing. It allows developers to write high-level algorithms that are automatically optimized for modern hardware architectures including CPUs, GPUs, and specialized accelerators.
1,194
188
$13M
DMD
DMD is the reference compiler for the D programming language, a systems programming language with C-like syntax and static typing that combines performance, control, and modeling power with safety and programmer productivity
1,177
198
$30M
Binaryen
Optimizer and compiler/toolchain library for WebAssembly
1,011
353
$18M
Miri
Miri is an interpreter for Rust's mid-level intermediate representation (MIR) that detects undefined behavior in Rust code. It acts as a dynamic analysis tool to help catch memory safety issues and other undefined behaviors at runtime that the Rust compiler cannot detect at compile time.
986
308
$2.7M
Torch-MLIR Project
Torch-MLIR is a project that integrates PyTorch with MLIR (Multi-Level Intermediate Representation), enabling the compilation and optimization of PyTorch models through MLIR's infrastructure. It provides a bridge between PyTorch's frontend and LLVM's MLIR compiler framework, allowing for better optimization and targeting of various hardware platforms.
887
118
$5.5M
SPIRV-Cross
SPIRV-Cross is a tool and library for performing reflection on SPIR-V and converting SPIR-V to other shader languages. It enables translation of SPIR-V shaders into GLSL, HLSL, MSL and other formats while preserving metadata and optimizations.
779
149
$11M
Eclipse JDT Core
Eclipse JDT Core is a Java development tools component that provides the core infrastructure for the Eclipse Java IDE, including a full-featured Java compiler, code analysis, manipulation and refactoring capabilities, and APIs for Java development tooling.
768
149
$68M
Slang
Slang is a shading language compiler and toolchain infrastructure designed for real-time graphics and compute applications. It provides a modern shader compilation system that supports multiple shading languages and target platforms, with features for code generation, optimization, and reflection.
723
130
$26M
Bear
Bear is a build log extraction tool that generates compilation databases for Clang tooling by intercepting compiler calls during the build process. It helps developers analyze and work with C/C++ codebases by capturing build commands and their parameters.
668
203
$531K
Scala Native
Scala Native is a compiler and toolchain that enables compiling Scala code to native executables using LLVM. It allows developers to write low-level system code in Scala while maintaining access to native libraries and achieving high performance through ahead-of-time compilation.
582
217
$15M
CIRCT
CIRCT (Circuit IR Compilers and Tools) is a framework for building circuit design tools and compilers, extending LLVM's infrastructure to support hardware design and synthesis. It provides intermediate representations and compiler tools for describing and manipulating circuits at various levels of abstraction.
562
126
$9.3M
Scalameta
Scalameta is a library and toolkit for parsing, analyzing, and transforming Scala code. It provides a clean, high-performance API for working with Scala syntax trees, semantic analysis, and metaprogramming capabilities.
468
170
$3M
Cranelift Codegen Backend for Rust
A project that implements a Cranelift code generation backend for the Rust programming language, enabling Rust to use Cranelift as an alternative compiler backend for generating machine code
447
151
$667K
LFortran
LFortran is a modern, interactive LLVM-based Fortran compiler designed to be both a development and production compiler. It features a modular architecture, can compile Fortran code to machine code, and provides interactive REPL capabilities for Fortran development.
428
90
$12M
Enzyme Automatic Differentiator
Enzyme is an automatic differentiation tool that performs reverse-mode AD by using LLVM compiler infrastructure to differentiate programs in languages like Julia, C/C++, and Fortran. It enables efficient gradient computation for machine learning and scientific computing applications.
372
130
$1.8M
slang
Slang is a SystemVerilog compiler and language tools library, providing parsing, elaboration, and analysis capabilities for SystemVerilog code. It is designed to be fast, memory efficient, and usable as a library in other applications.
343
58
$9M
XLS
XLS: Accelerated HW Synthesis
324
51
$28M
xDSL
A Python Compiler Design Toolkit
255
46
$5.3M
SBCL (Steel Bank Common Lisp)
SBCL (Steel Bank Common Lisp) is a high-performance Common Lisp compiler and runtime environment. It is derived from CMUCL and features native compilation, a comprehensive debugger, and extensive ANSI Common Lisp compliance. The system is self-hosting and provides robust support for multithreading, Unicode, and foreign function interfaces.
254
39
$36M