Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
3883 Projects Found
Sort by

Improve inter-procedural analyses and optimizations

intermediate
LLVM Compiler Infrastructure•2020$3k–$6.6k

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

<p>LLVM IR has some attributes which can be attached to function, argument, callsite, et cetera. These attributes guarantee a property corresponding to each attribute and its position, and such information is used to decide to apply a particular transformation in other optimization passes. These attributes are given by the frontend or inferred by LLVM passes.</p> <p>A framework for unified attribute inference named “Attributor” was introduced and implemented. In a GSoC project last year, various attributes can be inferred with Attributor. However, there is room for improvement of inference.</p> <p>The Attributor can not only deduce attributes but also connect attribute deduction and other analyses to each other. We can take advantage of this potential of Attributor. One of such optimizations is “value simplification”. It has been implemented, but it also can be improved.</p> <p>The purpose of this project is two-fold.</p> <ol> <li>To make some inference stronger and make it possible for more optimizations to be applied.</li> <li>To improve value simplification from various perspectives.</li> </ol>

cllvmc+++3
Student: Shinji Okumura
Code
Proposal

Polly as an Analysis Pass in LLVM

advanced
LLVM Compiler Infrastructure•2016Varies350h (Large)

<p>The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently, LLVM mainline lacks a powerful dependence analysis framework, and at the same time, Polly’s (a high level data locality optimizer based on polyhedral framework) dependence analysis is suitable for many transformation passes in LLVM like Loop Vectorization, Loop Versioning, Modulo Scheduling, Loop Nest Optimizations, etc. I want to provide an API to Polly such that its precise dependence analysis can be used as an Analysis pass within LLVM's transformation passes.</p>

cllvmc+++3
Student: Utpal
Code
Proposal

Improve inter-procedural analyses and optimizations

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>In this project we aim to improve the deduction capabilities of the Attributor framework.</p>

cllvmc+++3
Student: Kuter Dinel
Code
Proposal

Enhancing llvm-cov to Generate Hierarchical Coverage Reports

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

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. llvm-cov currently generates a single top-level index HTML/TEXT file. This causes rendering scalability issues in large projects. This project adds a new option `-show-directory-coverage` to llvm-cov which enables the generation of a hierarchical report mirroring the directory structure and solve scalability issues.

cllvmc+++3
Student: Yuhao Gu
Code
Proposal

Upstreaming -fbounds-safety

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

-fbounds-safety is a C language extension designed to prevent out-of-bounds memory accesses. Currently, upstream Clang provides partial support for some annotations such as counted_by. The proposal aims to extend the scope of the currently supported annotations and upstream missing ones.

cllvmc+++3
Student: Mohammed.Ashraf
Code
Proposal

Improved Loop Execution Modeling in Clang Static Analyzer

beginner
LLVM Compiler Infrastructure•2017Varies90h (Small)

<p>The current implementation of modeling a loop is quite simple in the Clang Static Analyzer. This simple approach results a loss of coverage, which indicates false negatives. There is already an implemented loop widening method in the Clang Static Analyzer.[1] However, it comes at the price that (almost) all of the MemRegions values will be invalidated. Hence, the false positive rate is relatively high in these paths. That is the reason it is not turned on by default but hidden behind a flag. My project would aim to improve the simulation of the loops in general. Moreover, it would provide an extensible and incremental way of loop widening in which only the relevant regions are invalidated, and thus can be turned on by default.</p> <p>[1] <a href="https://reviews.llvm.org/D12358" target="_blank">https://reviews.llvm.org/D12358</a></p>

cllvmc+++3
Student: Péter Szécsi
Code
Proposal

libObjectcopy

beginner
LLVM Compiler Infrastructure•2019Varies90h (Small)

<p>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 later. I think we can create a much better and more ergonomic object file library than GNU's bfd considering we can use it as an example. Also, I find C++ is much better suited for creating ergonomic and easy to use libraries than C, obviously. If the library exists internally for LLVM and by use of its binutils, then we can create a much better library. If done correctly, many of the binutils will just have to interface with the command line and with the library and do little work with the underlying object file on their own.</p>

cllvmc+++3
Student: Alex Brachet
Code
Proposal

Improve LLVM binary utilities

intermediate
LLVM Compiler Infrastructure•2019Varies175h (Medium)

<p>LLVM includes binary utilities equivalent to GNU binutils. Basic functionalities are done but there are incomplete ones such as Mach-O support. This project aims to support those missing functionalities and improve usability for those who crave for an alternative to GNU binutils.</p> <p>The goal of proposal is twofold:</p> <ul> <li>llvm-objcopy: Improve Mach-O support</li> <li>llvm-objdump: More human-friendly disassembly</li> </ul>

cllvmc+++3
Student: Seiya Nuta
Code
Proposal

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

intermediate
LLVM Compiler Infrastructure•2016Varies175h (Medium)

<p>A Module System for C++ is on its way to the C++ standard.</p> <p>The current state of the Module System, although fairly stable, it has a few bugs for C++ support. The most common reason for the bugs is the semantic merging of C++ entities. Currently, the method for ensuring no regressions is a buildbot for libc++, which builds llvm in modules self-hosted mode. Its main purpose is to find bugs in clang’s implementation and ensure no regression for the ongoing development.</p> <p>Since the Module Systems is meant to be generic, the project aims to improve the stability and coverage of the Module System by finding as many issues as possible. One approach is to add a buildbot for libstdc++, because this would change the merging model for the modules, and in this way, it will point out different issues which would not be observed by using libc++. The choice for libstdc++ is motivated by its wider use in Unix and, more importantly, the benefits it will bring to supporting modules for third party projects that rely on libstdc++.</p>

cllvmc+++3
Student: CrisCristescu
Code

Evolving the LLDB GUI

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>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 command line interface.</p>

cllvmc+++3
Student: Omar Emara
Code
Proposal

Non-Determinacy based optimizations in Parallel Programs

advanced
LLVM Compiler Infrastructure•2022Varies350h (Large)

Problem : Optimize Parallel Programs by employing Non-Determinacy based optimizations. Plan : 1. Perform static code analysis to identify program points for potential code optimizations. 2. Implement the optimizations as passes which will transform the source of the previously chosen program points. Following are the list of optimizations that are planned. a. Non-deterministic Loop Invariant Code Motion b. Loop interchange/reordering c. Non-deterministic Vectorization d. Non-deterministic Memory to Register 3. Evaluate the generated code for the optimizations against the benchmarks. 4. Documentation and Report a. Document the details with respect to the assumptions in the optimizations. b. Document the relevance of the optimization across the chosen benchmarks. Deliverables : a. Analysis to decide on the program segments to perform optimization b. Optimization passes on the previously chosen code segments. c. Optimization bench marking d. Documentation towards theory and implementation of optimizations

cllvmc+++3
Student: Abhishekvu
Code

Building bash-completion for clang

intermediate
LLVM Compiler Infrastructure•2017Varies175h (Medium)

<p>Shell completion is a function which developers use everyday. Typing "<em>ls -</em>" and pressing <em>[tab]</em> will return a list of probable options, and typing "<em>sudo apt ins</em>" and pressing <em>[tab]</em> will complete the last argument (in this case "install"). Since each command takes different arguments, shells need to be taught how to complete arguments for each command.</p> <p>The aim of this proposal is twofold:</p> <ul> <li>There’s no bash autocompletion support for clang at the moment. Therefore I will build bash-completion which <strong> works not only for the current version but for all future versions of clang.</strong></li> <li>Not merely implement completion for bash, but also <strong> make this project highly portable to any other shells (zsh, fish..etc) by implementing completion behavior in clang internals.</strong></li> </ul>

cllvmc+++3
Student: Yuka Takahashi
Code
Proposal

Warn if virtual calls are made from constructors or destructors

intermediate
LLVM Compiler Infrastructure•2017Varies175h (Medium)

<p>In C++, virtual functions let instances of related classes have different behavior at run time. Pure function called from constructors and destructors will make the C++ program crash and virtual function called from constructors and destructors may not do what you expect. This proposal is about implementing a path-sensitive checker to find virtual calls made from constructors and destructors.</p>

cllvmc+++3
Student: Xin Wang
Code
Proposal

Improve Parallelism-Aware Analyses and Optimizations

advanced
LLVM Compiler Infrastructure•2020Varies350h (Large)

<p>Parallelism is used to improve performance. In sequential languages, parallelism is introduced with parallel constructs. However, it doesn’t come without a downside. Early outlining by the frontend is preventing existing optimization passes. The intent is to enhance and improve the existing “OpenMPOpt” optimization pass, thus improving performance of parallel programs.</p>

cllvmc+++3
Student: Stefan Stipanovic
Code
Proposal

Interactive MLIR query tool to make exploring the IR easier

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

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 a REPL or command-line interface for users to query various properties of MLIR code. The goal is to create a tool similar to clang-query, with autocomplete and other features. The project's objective is to make it easier understand the MLIR IR representation, implement a REPL for executing queries over MLIR IR, and deliver a standalone tool for interactively exploring IR with common matchers. A stretch goal is to enable extracting parts of the IR matched by queries into self-contained IR snippets.

cllvmc+++3
Student: Devajith Valaparambil Sreeramaswamy
Code
Proposal

Clang-based C/C++ diff tool

intermediate
LLVM Compiler Infrastructure•2017Varies175h (Medium)

<p>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 visualizations of changes as well as semantic-aware merge tools.</p>

cllvmc+++3
Student: Johannes Altmanninger
Code
Proposal

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

intermediate
LLVM Compiler Infrastructure•2020Varies175h (Medium)

<p>LLVM transformation passes use code motion in different types of transformations. All these passes have some embedded code motion safety checks and mechanisms to move code. This project aims to identify different mechanisms for checking code motion safety and for moving code and then tries to unify them into one place. This will eventually provide a standardized way for different transformation passes to use code motion checks and to move code. The initial groundwork has already started in CodeMoverUtils. This project will focus on the code motion safety checks and the ways to move code in different loop passes, keeping CodeMoverUtils independent of any loop information. This will help to increase the maintainability of code motion safety checks and will reduce the redundancy and inconsistency of code motion safety checks and ways to move code.</p>

cllvmc+++3
Student: Rithik Sharma
Code

Rich Disassembler for LLDB

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

This project aims to enhance LLDB's disassembler by annotating machine instructions with source-level variable information, such as variable locations and lifetimes, based on debug data like DWARF. Currently, LLDB’s disassembler outputs only low-level instructions, requiring users to manually infer where source variables are located. By enriching disassembly output with variable annotations (e.g., which register or constant a variable is stored in), this project will make debugging optimized and low-level code significantly easier. The solution involves extending LLDB’s disassembly printing pipeline to query live variables at each instruction address, limited to variables that reside in CPU registers or are represented as constants, ensuring efficiency and clarity. Deliverables include: Annotated disassembly output in the LLDB command-line interface. Full test coverage against optimized and unoptimized binaries. Documentation and usage examples for developers and users. This work will be designed to be debug information format-agnostic wherever possible, making it extensible across formats like DWARF and PDB.

cllvmc+++3
Student: Abdullah_Amin
Code
Proposal

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

advanced
LLVM Compiler Infrastructure•2021Varies350h (Large)

<p>With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages' users begin to call for the ability to do high-performance and convenient <em>automatic differentiation</em> (hereafter AD) on functions, whereupon many AD tools are developed, among which is Enzyme. Enzyme is made as a plugin of LLVM and synthesizes differentiated functions directly on optimized LLVM IR code, which provides it with advantages in efficiency and universality. From another aspect, Rust is an emerging high-performance and safe language. Many of its users are trying to bring machine learning to it, thus an high-performance and user-friendly AD tool needed. Enzyme is a good option for this demand. However, without a deep integration into Rust, Enzyme's user experience with Rust is not so good, and more importantly, it may suffer from performance reduction due to wasted Rust meta-information. These problems hamper Enzyme from being widely used in Rust. This project will tackle the aforementioned problems through integrating Enzyme into Rust and then provide high-performance differentiation in Rust.</p>

cllvmc+++3
Student: Chuyang Chen
Code

Inlining: using locally optimal inlining decisions

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>Improve inlining: using subgraph analyze and locally optimal inlining decisions</p>

cllvmc+++3
Student: Liq Tao
Code
Proposal

Finding and analysing copy-pasted code with clang

intermediate
LLVM Compiler Infrastructure•2016Varies175h (Medium)

<p>Copy-pasted code is dangerous because it introduced bugs and makes projects harder to maintain. This proposal is about creating tools for finding copy-pasted code and report bugs that are caused by this practice. These tools include a checker for clang’s static analyzer that analyses a single translation unit and a standalone tool that performs a project-wide analysis.</p>

cllvmc+++3
Student: Teemperor
Code
Proposal

Distributed lit testing

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>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, even on a high-spec computer. Builds are already distributable across multiple computers available on the same network, using software such as distcc or icecream, so running tests on a single machine becomes a potential bottleneck. One way to speed up running of the tests could be to distribute test execution across many computers too. Lit provides a test sharding mechanism, which allows multiple computers to run parts of the same testsuite in tandem, but this currently assumes access to a single common filesystem, which may not be possible in all cases and a knowledge of which machines the suite can currently be run on.</p>

cllvmc+++3
Student: Soham Dixit
Code
Proposal

Write JITLink support for new format/architecture

intermediate
LLVM Compiler Infrastructure•2022Varies175h (Medium)

JITLink is LLVM’s new JIT linker designed to support a variety of new features, which includes full static initializer, thread local storage, and small code model, that were not possible in RuntimeDyld, the old JIT linker API. JITLink’s generic linker algorithm needs to be specialized to support the target object format (COFF, ELF, MachO), and architecture (arm, arm64, i386, x86-64). This project aims to implement the JITLink specialization for ELF/aarch64 and COFF/x86-64.

cllvmc+++3
Student: Sunho Kim
Code
Proposal

Add DWARF Support for yaml2obj

intermediate
LLVM Compiler Infrastructure•2020Varies175h (Medium)

<p>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 one does the reverse, reads object files and emits YAML files. We use these tools to write unit tests for binary tools, e.g., llvm-objdump, llvm-nm, llvm-readelf, as YAML is easier to read and edit than raw assembly codes and pre-built binaries. More importantly, YAML keeps our tests code base maintainable. However, yaml2obj currently doesn’t support generating DWARF sections very well (we have to hardcode the Content field of DWARF sections and it is not intuitive). This project aims to add DWARF support for yaml2obj (ELF part), which will ease our pain crafting DWARF tests.</p>

cllvmc+++3
Student: Xing GUO
Code
Proposal
Showing 313 - 336 of 3883 Projects
1213141516
Proposal
Proposal
Proposal
Proposal