Back to Programs

Programming languages

LLVM Compiler Infrastructure

LLVM Compiler Infrastructure

c++clangllvmmlir
Organization website

Participation history

11 GSoC years

20262025202420232022202120202019201820172016

2026

13 projects

Official year page

Incremental build support for the modules driver

Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the...

Project page

Teach the Clang Static Analyzer to understand lifetime annotations

The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers,...

Project page

CIR Combine: Cross-Boundary Analysis for Heterogeneous CUDA/HIP Compilation

Today, LLVM's offload compilation keeps host and device code strictly separate; they only reunite late in the pipeline when the device binary is...

Project page

Extending Clang API Notes for C++: Overload-Specific Annotations for Ordinary Methods

This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between...

Project page

Adding native Fortran support in LLDB

As the LLVM Flang frontend matures, a significant gap has emerged between compilation and diagnostic capabilities. Currently, LLDB does not provide...

Project page

Integrating a Remarks Analysis Engine into LLVM Advisor

This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation...

Project page

Static Memory Planner for MLIR

MLIR already makes allocation and deallocation structure explicit after bufferization and the ownership-based deallocation pipeline, but it still...

Project page

Enable clangd support for HLSL

The goal of this project is to enable support for the High-Level Shading Language (HLSL) in clangd, allowing shader developers to benefit from modern...

Project page

Use LLVM libc math routines for compiler-rt floating point routines

compiler-rt builtins provide software floating-point routines (__addtf3, __multf3, __floatsitf, etc.) for targets that lack hardware FP support. The...

Project page

Upstreaming -fbounds-safety

-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for...

Project page

Improving Clang-Doc

Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption...

Project page

Improving lit

This project aims to modernize the LLVM Integrated Tester (lit) to improve its execution speed and long-term maintainability. Performance is...

Project page

Enable float80/float128 on Unsupported Targets for LLVM libc

This proposal is based on the LLVM project for GSoC 2026 with the same title, from Tue Ly, Nicolas Celik and Krishna Pandey. Discourse:...

Project page

2025

13 projects

Official year page

Rich Disassembler for LLDB

This project aims to enhance LLDB's disassembler by annotating machine instructions with source-level variable information, such as variable...

CodeProject page

ClangIR upstreaming

ClangIR is a new, MLIR-based intermediate representation of C and C++ code. It has been developed in an LLVM incubator project, but work is now...

CodeProject page

Usability Improvements for trapping Undefined Behavior Sanitizer

The primary vision is to enhance clang’s UBSan trap mode by tackling the three main goals, which include adding a warning to the...

CodeProject page

Improving Core Clang-Doc Functionality

Clang-Doc leverages Clang’s robust tooling and rich symbol information in the AST to generate documentation. It is lacking in some essential...

CodeProject page

Improve Rust-Enzyme Reliability and Compile Times

Enzyme, Rust's automatic differentiation tool, faces challenges with reliability and performance due to limited type information in LLVM-IR. This...

CodeProject page

Bfloat16 in LLVM libc

This proposal is based on the LLVM project for GSoC 2025 with the same title, from Tue Ly and Nicolas Celik. Discourse:...

CodeProject page

Performance and Exhaustive Testing of C Standard Math Functions on GPUs

This proposal aims to refine and expand the testing infrastructure in the LLVM C library to help users balance speed and accuracy of math functions...

CodeProject page

LLVM Compiler Remarks Visualization Tool for Offloading

LLVM generates valuable information through remarks, profiling, and runtime annotations that becomes difficult to navigate as projects grow. This...

CodeProject page

Introduce an ABI lowering library

The current implementations of the LLVM Project, have a drawback that every language frontend that wants to support Foreign Function Interface(FFI)...

CodeProject page

Support simple C++ modules use from the Clang Driver without a Build System

This proposal seeks to extend the build system in Clang's driver to natively support module-based builds by leveraging Clang's existing support for...

CodeProject page

Byte type

LLVM currently lacks a type capable of representing raw memory, similar to unsigned char, char and std::byte in C/C++. The absence of such a type is...

CodeProject page

Improve I/O performance in the libc implementation for GPU using io_uring

Many HPC applications rely on GPUs for fast and efficient computation. At the same time, there is an effort to bring more programmability and...

CodeProject page

Advanced symbol resolution and reoptimization for clang-repl

Clang-REPL is an incremental compiler that enables interactive programming in C and C++, combining the flexibility of a REPL with the performance of...

CodeProject page

2024

12 projects

Official year page

GPU Libc Benchmarking

The LLVM libc project was designed as an alternative to glibc that aims to be modular, configurable, and sanitizer-friendly. Currently, LLVM libc is...

CodeProject page

Support clang plugins on Windows

This project aims to allow using dynamically loaded Clang plugins on windows by adding support for building LLVM and Clang as shared libraries on...

CodeProject page

Improve Clang-Doc

Clang-Doc is a documentation generator developed on top of libtooling developed as an alternative to Doxygen. Development started in 2018, and...

CodeProject page

OpenCL C Support for ClangIR

Optimizing code for heterogeneous hardware like GPUs requires specialized approaches. While LLVM/Clang supports various GPU programming interfaces,...

CodeProject page

Out of process execution for Clang-Repl

Clang, part of LLVM, supports multiple languages and functions as a library, fostering a compiler-assisted ecosystem. Its accessible codebase and...

CodeProject page

Reviving NewGVN

Value numbering is a key compiler optimization. Currently, LLVM’s optimizer offers two implementations, GVN and NewGVN, neither of which is entirely...

CodeProject page

Statistical Analysis of LLVM-IR Compilation

This project aims to provide an analysis of the causes of unexpected compilation times. By conducting a statistical analysis on IR files available on...

CodeProject page

LLVM.org Website Redesign

Problem Statement: Redesigning and migrating the llvm.org website to enhance user experience, accessibility, and community engagement. Solution...

CodeProject page

Half precision in LLVM libc

This proposal is based on the open LLVM project with the same title, from Tue Ly and Joseph Huber. See...

CodeProject page

Addition of 3-way comparison intrinsic to LLVM

Three-way comparisons are present in many high-level programming languages, such as C++ with its spaceship (<=>) comparison operator or Rust via the...

CodeProject page

Build & Run SingleSource Benchmarks with ClangIR - Part 2

ClangIR is the newest attempt to tackle the lack of a higher-level intermediate representation for C++. Said representation would greatly benefit the...

CodeProject page

The 1001 thresholds in LLVM

LLVM has lots of thresholds and flags to avoid “costly cases”. However, it is unclear if these thresholds are useful, their value is reasonable, and...

CodeProject page

2023

20 projects

Official year page

ExtractAPI while building

This project aims to give LLVM-clang the ability to generate ExtractAPI symbol graph files as a side-effect of a regular compilation job. This can...

CodeProject page

WebAssembly Support for clang-repl

Clang includes libInterpreter, a framework for incrementally JIT compiling and executing C++ code. The goal of the project is to port this to...

CodeProject page

Modules Build Daemon: Build System Agnostic Support for Explicitly Built Modules

This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules...

CodeProject page

Interactive MLIR query tool to make exploring the IR easier

This project aims to create an interactive query language for MLIR that will allow developers to dynamically query the MLIR IR. The tool will provide...

CodeProject page

Improving Compile Times

This project aims to reduce the amount of time that LLVM spend on compiling code by focusing on hotspots in the code identified by profiling...

CodeProject page

Adding C++ Support to Clang's ExtractAPI

Clang’s ExtractAPI extracts information from C and Objective-C codebases to describe public API symbols and the relationships between them. It is...

CodeProject page

Optimizing MLIR’s Presburger library

MLIR’s Presburger Library, FPL, provides mathematical abstractions for polyhedral compilation and analysis. When many set operations are performed in...

CodeProject page

Adapting IR Load Semantics to Freeze All or Freeze Only Uninitialized Data

This proposal outlines a continuation of the Google Summer of Code (GSoC) 2022 topic to move uninitialized memory to poison semantics. Starting with...

CodeProject page

Addressing Rust optimization failures in LLVM

Rust is a popular system programming language that relies on LLVM for its compilation. Rust has a variety of features and paradigms and states “Zero...

CodeProject page

Tutorial development with clang-repl

This project aims to develop tutorials demostrating the current capabilities of clang-repl. It also aims to investigate and research the requirements...

CodeProject page

Fix Handling of Undefined Behavior in NewGVN

NewGVN was introduced to LLVM to cope with the limitations of the old GVN. It hasn't, however, seen widespread adoption, due to its bugs and missing...

CodeProject page

Map LLVM values to corresponding source-level expressions

This project aims to improve the accuracy of compiler-generated remarks and analysis reports by including corresponding source-level expressions in...

CodeProject page

Machine Learning Guided Ordering of Compiler Optimization Passes

Standard optimization pipelines are used by developers to compile programs in LLVM clang like (O1, O2, O3, etc…). These are based on heuristics that...

CodeProject page

Patch based test coverage for quick test feedback

Most of the day to day tests in LLVM are regression tests executed by Lit, structured as source code or IR to be passed to some binary, rather than...

CodeProject page

Re-optimization using JITLink

In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some...

CodeProject page

Improvements in Clang Diagnostics

Clang diagnostic is an interface for programmers that assists them in writing bug-free, efficient source codes. The aim of this proposal is to...

CodeProject page

Build & Run SingleSource Benchmarks with ClangIR

ClangIR is the newest attempt to tackle the lack of a higher-level intermediate representation for C++. Said representation would greatly benefit the...

CodeProject page

Better Performance Models for MLGO Training

This project aims to improve the reward signal used in the RL-based training of MLGO models. I plan to integrate an existing GNN-based performance...

CodeProject page

Enhancing llvm-cov to Generate Hierarchical Coverage Reports

Clang supports source-based coverage that shows which lines of code are covered by the executed tests. It uses llvm-cov to generate coverage reports....

CodeProject page

Autocompletion in Clang-REPL

Clang-REPL enables developers to program in C++ in an exploratory manner via a read-eval-print-loop. Developers, however, have to type each letter or...

CodeProject page

2022

13 projects

Official year page

Make Enzyme plugin callable from The New Pass Manager in LLVM

Enzyme plugin project aims to automatically find derivatives of LLVM IR which is pretty helpful for ML related works.Enzyme code base still uses the...

CodeProject page

Graph Based Features for Better ML Guided Live Range Eviction Heuristics

Within this project, I aim to create a new ML model based on the already existing MLGO work in register allocation to further enhance the performance...

CodeProject page

Improving Clang Diagnostics

Improving the clang diagnostics focuses on the diagnostic section of clang. This proposal is meant to make clang diagnostic more user friendly and...

CodeProject page

Moving Instruction Rules to Tablegen

Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. The support for an increasing number of LLVM Versions (7-main),...

CodeProject page

Non-Determinacy based optimizations in Parallel Programs

Problem : Optimize Parallel Programs by employing Non-Determinacy based optimizations. Plan : 1. Perform static code analysis to identify program...

CodeProject page

Write JITLink support for new format/architecture

JITLink is LLVM’s new JIT linker designed to support a variety of new features, which includes full static initializer, thread local storage, and...

CodeProject page

Learning loop transformation policy and it's effect on RISC-V

This project is based on the proposed project (Learning Loop Transformation Policies) by the mentors Johannes Doerfert, Mircea Trofin. This project...

CodeProject page

Remove undef: Move Uninitialized Memory to Poison

Current memory semantics of the LLVM-IR use undef when dereferencing an uninitialized memory location. This prevents optimizations within scalar...

CodeProject page

Implement support for C++17 structured bindings in the Clang Static Analyzer

Even though a lot of new C++ features are supported by the static analyzer automatically by the virtue of clang AST doing all the work under the...

CodeProject page

Shared Memory Based JITLink Memory Manager

When a separate executor process is used with LLVM JIT, the generated code needs to be transferred to the executor process which is done by the...

CodeProject page

Learning Live Ranges Priority Policy

This project is a practical application under the umbrella of the MLGO framework. While the previous work focuses on inlining and eviction policy of...

CodeProject page

Instrumentation of Clang/LLVM for Compile Time

GSoC Project "Instrumentation of Clang/LLVM for Compile Time" aims to solve a simple but interesting question: Why is the compilation taking so long?...

CodeProject page

Extend clang to preserve type sugar when performing member access on template specialization

For an example like: template<class T> struct Foo { using type = T; }; using Bar = int; Foo<Bar>::type baz; In clang, baz’s type will not desugar to...

CodeProject page

2021

16 projects

Official year page

Fix Fundamental Issues in LLVM IR

LLVM Project is a collection of modular and reusable compiler and toolchain technologies. It supports various high-level languages and hardware...

CodeProject page

Machine Learning Guided Ordering of Compiler Optimization Passes

Developers generally use standard optimization pipelines like -O2 and -O3 to optimize their code. Manually crafted heuristics are used to determine...

CodeProject page

Making Smart Pointer Checkers default checkers in the Static Analyzer

The Clang Static Analyzer currently has checkers for std::unique_ptr. These checkers are currently in the experimental (alpha) group of checkers. I...

CodeProject page

Learning Loop Transformation Heuristics

In this project we will look at loop transformation heuristics, such as the unroll factor.

CodeProject page

Integrate custom derivatives of Numerical Computing routines like BLAS and Eigen into Enzyme

Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. This enables users to use Enzyme to perform various algorithms...

CodeProject page

Improving OpenMP code generation with prediction of runtime parameters

The performance of the code generated for the GPU heavily depends on runtime parameters such as the number of thread blocks and threads per thread...

CodeProject page

Distributed lit testing

The LLVM lit test suites consist of thousands of small independent tests. Due to the number of tests, it can take a long time to run the full suite,...

CodeProject page

Fix miscompilation issues in LLVM IR using the ‘Freeze’ instruction

Optimizations have been the cause of multiple miscompilations as well. It is difficult to determine whether an optimization is correct because bugs...

CodeProject page

Integrate Enzyme into Rust to Provide High-performance Differentiation in Rust

With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages'...

CodeProject page

Utilize LoopNest Pass

A newly added idea of LoopNest pass enables to handle a loop nest efficiently, unlike function pass or loop pass. The goals of this project are: ...

CodeProject page

Improve inter-procedural analyses and optimizations

In this project we aim to improve the deduction capabilities of the Attributor framework.

CodeProject page

Use official isl C++ bindings for polly

Polly uses custom C++ bindings for isl (Integer Set Library) which is a library written in C. I aim to replace at least partially the usage of these...

CodeProject page

Fixing fundamental issues in LLVM IR: Introducing a byte type to solve load type punning

It is common for compilers, and LLVM in particular, to transform calls to memcpy or memmove to a number of integer loads and stores of the...

CodeProject page

Integrating Enzyme into Rust

Integrate Enzyme into Rust to provide high-performance differentiation of generic Rust code.

CodeProject page

Evolving the LLDB GUI

The project aims to improve the LLDB curses GUI to provide a complete and intuitive IDE-like debugging experience without having to resort to the...

CodeProject page

Inlining: using locally optimal inlining decisions

Improve inlining: using subgraph analyze and locally optimal inlining decisions

CodeProject page

2020

15 projects

Official year page

Improve Parallelism-Aware Analyses and Optimizations

Parallelism is used to improve performance. In sequential languages, parallelism is introduced with parallel constructs. However, it doesn’t come...

CodeProject page

Add DWARF Support for yaml2obj

LLVM offers 2 useful YAML tools, yaml2obj and obj2yaml. The former one reads YAML files and emits object files, e.g., ELF, COFF and MachO. The latter...

CodeProject page

Advanced Heuristics for Ordering Compiler Optimization Passes

Selecting optimization passes for given application is very important but non-trivial problem because of the huge size of the compiler transformation...

CodeProject page

Improve hot cold splitting to aggressively outline small blocks

This project aims at enhancing the ability to detect and split small cold blocks (for example, __assert_rtn, throws) to the existing hot/cold...

CodeProject page

Unify ways to move code or check if code is safe to be moved

LLVM transformation passes use code motion in different types of transformations. All these passes have some embedded code motion safety checks and...

CodeProject page

Support autosuggestions in LLDB's command line

Tab completion in LLDB is a very useful function for users. However, it is needed that users press [tab] key to confirm completion. If they can...

CodeProject page

Advanced Heuristics for Ordering Compiler Optimization Passes

Compilers come with hundreds of optimization passes, making it difficult to select which passes to run and deciding the order in which to execute...

CodeProject page

Implement the missing tab completions for LLDB's command line

To implement the missing tab completions for LLDB's command line as the title goes, I dug out possible commands as targets and provided a list of...

CodeProject page

SPIR-V to LLVM IR dialect conversion in MLIR

MLIR is a novel compiler infrastructure that enables multi-level abstraction and therefore enhances reusability and extensibility. The core concept...

CodeProject page

Find null smart pointer dereferences with the Static Analyzer

The Clang Static Analyzer is used to find bugs in the program by analyzing source code without compiling and executing. It uses symbolic computations...

CodeProject page

Improve inter-procedural analyses and optimizations

LLVM IR has some attributes which can be attached to function, argument, callsite, et cetera. These attributes guarantee a property corresponding to...

CodeProject page

Latency Hiding for Host to Device Memory Transfers

Given the increasing number of use cases for massively parallel devices (GPUs), solving the problems they bring have become an important research...

CodeProject page

Improve MergeFunctions to incorporate MergeSimilarFunctions patches and ThinLTO Support

The project aims at providing the MergeFunctions pass in LLVM to have feature parity with the MergeSimilarFunctions pass, which can merge functions...

CodeProject page

Improve inter-procedural analyses and optimizations

In this project we aim to improve the deduction capabilities of the Attributor framework.

CodeProject page

Deduce attributes for non-exact functions

A function that is non-exactly defined is a function that could be replaced at link time. Usually most of the non-inlining IPOs are inhibited. For...

CodeProject page

2019

8 projects

Official year page

libObjectcopy

Working on librarifying llvm-objcopy for use throughout binutils. Creating a good base for a library such that many object file formats can be added...

CodeProject page

Improve (function) attribute inference

LLVM functions can be tagged with several attributes. These attributes are used in optimizations to decide whether a particular transformation is...

CodeProject page

Improve (function) attribute inference

LLVM functions, as well as arguments and other entities, can be tagged with several attributes such as the function only reads memory, or the...

CodeProject page

Speculative compilation in LLVM ORC - Just in time APIs

One of the selling points of new LLVM ORC Concurrent JIT APIs is we can speculatively compile functions before we need it, with the hope that when we...

CodeProject page

Apply the Clang Static Analyzer to LLVM-based projects

The idea is to improve the Clang Static Analyzer so that it is useful for developers who work on Clang and LLVM themselves, as well as on other...

CodeProject page

Generation of Annotated Sources

LLVM automatically derives facts that are only used while the respective translation unit, or LLVM module, is processed (i.e. constant function,...

CodeProject page

Improve LLVM binary utilities

LLVM includes binary utilities equivalent to GNU binutils. Basic functionalities are done but there are incomplete ones such as Mach-O support. This...

CodeProject page

Enhancing bug reports in the Clang Static Analyzer

The Clang Static Analyzer (analyzer) can discover errors in a code by a technique called symbolic execution. Its core essentially interprets C, C++,...

CodeProject page

2018

8 projects

Official year page

Implement a single updater class for Dominators

Dominance relationship is used widely in many compiler analyses and optimizations. The current API provided by LLVM to update the dominator tree and...

CodeProject page

Re-implement lldb-mi on top of the LLDB public API

The project goal is to re-implement lldb-mi to avoid using of HandleCommand and regular expressions to parse commands results.

CodeProject page

Using the Z3 SMT Solver to Validate Bugs Reported by the Clang Static Analyzer

The goal of this project is to provide a new option in the clang static analyzer to validate (or refute) reported bugs, by using an SMT solver. The...

CodeProject page

Move the apt.llvm.org CI to OBS

LLVM uses a Jenkins instance and Jenkins-Debian-Glue to build LLVM, Clang, clang extra tools, compiler-rt, polly, LLDB and LLD packages for the...

CodeProject page

A checker for dangling string pointers in C++

The C++ std::string class provides a c_str() method that returns a raw pointer to a string's inner character buffer. When a std::string is destroyed,...

CodeProject page

Improve Debugging of Optimized Code

Measure DebugInfo loss statistics. Find the cause. Fix the culprit transformations starting from the most used areas of the compiler.

CodeProject page

Devirtualization v2

In this project I would like to implement proposal “RFC: C++ Devirtualization v2” that I was working on for a quite some time with help from other...

CodeProject page

Command line replacements for GNU Binutils

A lot of GNU binutils have their equivalent in the LLVM project. As the majority of people are already accustomed to the GNU ones, it would be great...

CodeProject page

2017

8 projects

Official year page

ThinLTO Optimizations

I would like to work on ThinLTO to improve and tune performance. This will require some analysis to determine what optimizations to add, as well as...

CodeProject page

Clang-based C/C++ diff tool

I want to implement a structural diff tool atop of clang APIs that finds changes to the AST between two versions of a file. This would enable better...

CodeProject page

Warn if virtual calls are made from constructors or destructors

In C++, virtual functions let instances of related classes have different behavior at run time. Pure function called from constructors and...

CodeProject page

Enable Polyhedral Optimizations in XLA through LLVM/Polly

TensorFlow is a popular machine learning and deep learning framework developed by Google. Despite its recent launch in late 2015, it has been widely...

CodeProject page

ISL Memory Management Using Clang Static Analyzer

Maintaining consistency while manual reference counting is very difficult. Languages like Java, C#, Go and other scripting languages employ garbage...

CodeProject page

Building bash-completion for clang

Shell completion is a function which developers use everyday. Typing "ls -" and pressing [tab] will return a list of probable options, and typing...

CodeProject page

Improved Loop Execution Modeling in Clang Static Analyzer

The current implementation of modeling a loop is quite simple in the Clang Static Analyzer. This simple approach results a loss of coverage, which...

CodeProject page

Enabling Julia to target GPGPUs using Polly

Polly can now automatically offload suitable kernels to GPUs in the form of Polly-ACC, saving a lot of developer time and effort. Julia, a modern...

CodeProject page

2016

7 projects

Official year page

Finding and analysing copy-pasted code with clang

Copy-pasted code is dangerous because it introduced bugs and makes projects harder to maintain. This proposal is about creating tools for finding...

CodeProject page

Interprocedural Register Allocation in LLVM

The objective of this project is to implement a simple interprocedural register allocation that attempts to minimize register spill code by...

CodeProject page

SAFECode’s Memory Policy Hardening

Monolithic kernels, like linux, did not provide a hardening mechanism on the kernel modules’ memory access. Modules in Linux could do almost...

CodeProject page

Improvement of vectorization process in Polly

Polly can perform classical loop transformations, exploit OpenMP level parallelism, expose SIMDization opportunities. However, due to the lack of a...

CodeProject page

Enabling llvm’s self-hosted modules builds using libstdc++

A Module System for C++ is on its way to the C++ standard. The current state of the Module System, although fairly stable, it has a few bugs for C++...

CodeProject page

Polly as an Analysis Pass in LLVM

The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently,...

CodeProject page

Better Alias Analysis By Default

The cfl-aa pass implemented by Gerorge Burgess IV back in GSoC 2014 is a fast, precise and interprocedural analyses that overcomes many deficiencies...

CodeProject page