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

Warn if virtual calls are made from constructors or destructors

intermediate
LLVM Compiler Infrastructure•2017Varies

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>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

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

advanced
LLVM Compiler Infrastructure•2021Varies350h (Large)

<p>Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. This enables users to use Enzyme to perform various algorithms such as back-propagation in ML or scientific simulation on existing code for any language that lowers to LLVM. Enzyme does so by applying the chain rule to every instruction in every function called by the original function to be differentiated. While functional, this is not necessarily optimal for high-level matrix operations which may have algebraic properties for faster derivative computation. Many programs use BLAS libraries to efficiently compute matrix and tensor operations. This project would enable high-performance automatic differentiation of BLAS and similar libraries (such as Eigen) by specifying custom derivative rules for their operations.</p> <p>At the end of this Google Summer of Code project, Enzyme should be able to automatically calculate the optimal derivatives of several common linear algebra functions, thereby implicitly allowing easier integration of Enzyme in several mathematical computing libraries.</p>

cllvmc+++3
Student: Pratyush Das
Code

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

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

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

Devirtualization v2

intermediate
LLVM Compiler Infrastructure•2018Varies175h (Medium)

<p>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 people. The proposal can be seen here: <a href="https://docs.google.com/document/d/16GVtCpzK8sIHNc2qZz6RN8amICNBtvjWUod2SujZVEo/edit?usp=sharing" target="_blank">https://docs.google.com/document/d/16GVtCpzK8sIHNc2qZz6RN8amICNBtvjWUod2SujZVEo/edit?usp=sharing</a></p>

cllvmc+++3
Student: Piotr Padlewski
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

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

Improving OpenMP code generation with prediction of runtime parameters

advanced
LLVM Compiler Infrastructure•2021Varies350h (Large)

<p>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 block. For this reason, a proper choice of such parameters based on both the IR information and runtime information can give a tangible improvement of the performance of the generated code. In this project, we will explore the ML-based approach to this problem which uses machine learning models for making a decision on the runtime parameter values given the IR and runtime features.</p>

cllvmc+++3
Student: Konstantin Sidorov
Code
Proposal

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

advanced
LLVM Compiler Infrastructure•2021Varies350h (Large)

<p>Optimizations have been the cause of multiple miscompilations as well. It is difficult to determine whether an optimization is correct because bugs occur in corner cases and it’s hard to test them all for each optimization. But, thanks to Alive2, we can formally check the correctness of optimizations. Many of the bugs found are related to the notion of undef and poison values in LLVM. The semantics of these values has been formalized recently, and existing optimizations are being fixed to match the semantics. For example, branching on undef is now defined as undefined behavior (UB), and several branch-related optimizations are being fixed. However, fixing some of the optimizations requires further work, mainly due to performance concerns. One representative example is loop unswitch: it is incorrect, but still unfixed because fixing it causes big regressions in some benchmarks. Our goal is to fix such miscompilations with minimal-to-no performance regression. This project will investigate what is necessary to recover slowdowns and upstream the patches to LLVM.</p>

cllvmc+++3
Student: Hyeongyu Kim
Code

Implement the missing tab completions for LLDB's command line

intermediate
LLVM Compiler Infrastructure•2020Varies175h (Medium)

<p>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 implementation solutions for them. Things remained are coding and testing.</p>

cllvmc+++3
Student: Gongyu Deng
Code
Proposal

ThinLTO Optimizations

advanced
LLVM Compiler Infrastructure•2017Varies350h (Large)

<p>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 implementing some known optimizations that haven’t been included yet. Specifically, I would like to add more attributes to the ThinLTO indexes’ global variable and function summaries to increase performance.</p>

cllvmc+++3
Student: Charles Saternos
Code
Proposal

Apply the Clang Static Analyzer to LLVM-based projects

intermediate
LLVM Compiler Infrastructure•2019Varies175h (Medium)

<p>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 LLVM-based projects, like Swift. LLVM makes use of C++ language features that the Static Analyzer has not yet been taught to understand. The analyzer also has false positives on some C++ idioms commonly used in the LLVM codebase.</p>

cllvmc+++3
Student: Charusso
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

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

Interprocedural Register Allocation in LLVM

beginner
LLVM Compiler Infrastructure•2016Varies90h (Small)

<p>The objective of this project is to implement a simple interprocedural register allocation that attempts to minimize register spill code by propagating register usage information through the program call graph. By examining the register usage information at each call site, the intraprocedural register allocator can avoid assigning registers already used in the called routines and minimizing spill code. Stretch goal for this project would be a link time register allocator. In this register allocation is deferred till linking of the code to optimize the allocation.</p>

cllvmc+++3
Student: Vivek Pandya
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

Support clang plugins on Windows

intermediate
LLVM Compiler Infrastructure•2024Varies175h (Medium)

This project aims to allow using dynamically loaded Clang plugins on windows by adding support for building LLVM and Clang as shared libraries on Windows with all the public c++ API exported and dynamically linking to them. Part of the process will be automated with a tool built using the Clang tooling API to automatically add export macros on the appropriate class and functions declarations in llvm public headers. Deliverables: End users can use custom clang plugins with official windows build of Clang. The llvm windows binary install size can be greatly decreased by dynamically linking llvm tools to the LLVM and Clang shared libraries.

cllvmc+++3
Student: thomas fransham
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

The 1001 thresholds in LLVM

beginner
LLVM Compiler Infrastructure•2024Varies90h (Small)

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 what impact they really have. Since there are a lot, one cannot do a simple exhaustive search. An example of work in this direction includes the introduction of a C++ class that can replace hardcoded values which offers control over the threshold, e.g., one can increase the recursion limit via a command line flag from the hardcoded “6” to a different number. In this project I will explore the thresholds when they are hit, what it means if they are hit, how we should select their values, and if we need different “profiles”.

cllvmc+++3
Student: Sh0g0
Code
Proposal

Improving Core Clang-Doc Functionality

intermediate
LLVM Compiler Infrastructure•2025Varies175h (Medium)

Clang-Doc leverages Clang’s robust tooling and rich symbol information in the AST to generate documentation. It is lacking in some essential functionality such as not supporting some fundamental C++ language constructs, not supporting Doxygen comment commands used in Clang's source code, and not being able to render Markdown. These are essential features in modern documentation tools that should be addressed for Clang-Doc's core feature set.

cllvmc+++3
Student: Erick Velez
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

Learning Loop Transformation Heuristics

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

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

cllvmc+++3
Student: Ali Sedaghati
Code
Proposal
Showing 337 - 360 of 3883 Projects
1314151617
Proposal
Proposal
Proposal
Proposal
Proposal