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

Machine Learning Guided Ordering of Compiler Optimization Passes

advanced
LLVM Compiler Infrastructure•2023Varies

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 →
350h (Large)

Standard optimization pipelines are used by developers to compile programs in LLVM clang like (O1, O2, O3, etc…). These are based on heuristics that follow a one size fits all approach. These are not specifically tailored to any one type of program such as call heavy, pointer heavy, etc… which leads to suboptimal binaries being generated. We want to improve the optimization phases of the LLVM Clang compiler through the use of Machine Learning to select the minimum optimization pipeline, from a pre-set of options, that produces the exact same optimized code. Integrating the machine learning model into the existing LLVM compiler infrastructure is one of the key areas of this project.

cllvmc+++3
Student: Puneeth A R
Code
Proposal

Improve Rust-Enzyme Reliability and Compile Times

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

Enzyme, Rust's automatic differentiation tool, faces challenges with reliability and performance due to limited type information in LLVM-IR. This project proposes to enhance Enzyme by extending the Rust compiler to lower richer type information from MIR into LLVM-IR metadata. This will involve improving the MIR type parser and generating accurate metadata. Deliverables include an extended MIR parser, new Rust compiler LIT tests demonstrating improved Enzyme functionality, comprehensive documentation, and a final report. This work aims to significantly improve the reliability and efficiency of automatic differentiation in Rust.

cllvmc+++3
Student: Karan Janthe
Code
Proposal

Integrating a Remarks Analysis Engine into LLVM Advisor

advanced
LLVM Compiler Infrastructure•2026Varies350h (Large)

This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation restructures the underlying data layer with a high-performance, dual-path ingestion pipeline, primary path being native C++ libRemarks bitstream decoding to process massive LTO builds without memory exhaustion, and the fallback path is YAML ingestion pipeline. It also implements a dependency-free Vanilla JS virtualization grid and injecting "Active Diagnostic" modules (like heuristic hinting and spatial heatmaps) directly into the existing Code Explorer DOM. This provides LLVM developers with bottleneck triage and actionable C++ refactoring advice while still maintaining the tool's lightweight, offline-first design.

cllvmc+++3
Student: kamini08
Code
Proposal

Integrating libSyntax with the Rest of the Compiler Pipeline

intermediate
Swift•2019Varies175h (Medium)

<p>Over the last couple of years, the Swift compiler has gained a new library called libSyntax. Its purpose is to represent the syntax of Swift source code with full fidelity (including white-space), enable structured editing and provide immutable, thread-safe data structures.</p> <p>This paper proposes that the Swift parser fully embraces the new libSyntax library in its parser and stops emitting ASTs. This will allow more parts of the compiler pipeline to eventually leverage the capabilities of the new library.</p>

llvmc++cmake+5
Student: Jan Svoboda
Code
Proposal

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

advanced
LLVM Compiler Infrastructure•2026Varies350h (Large)

Today, LLVM's offload compilation keeps host and device code strictly separate; they only reunite late in the pipeline when the device binary is embedded into the host object. By that point, cross-boundary reasoning is largely out of reach. CIR Combine introduces a merge-optimize-split stage into ClangIR's compilation pipeline. After both host and device modules are compiled to CIR, a new driver action merges them into a single heterogeneous translation unit, an offload container holding both modules as nested regions. With both sides visible simultaneously, cross-boundary analysis passes can propagate constants from host launch sites into device kernels, eliminate kernels that are never launched, and infer launch dimensionalities that inform device-side optimization. A subsequent split action extracts the transformed modules and feeds them back into their respective backend pipelines. Deliverables: - Working merge/split skeleton integrated into the new offload driver - Cross-boundary constant propagation pass validated on real CUDA/HIP kernels - Compile-time overhead measurements, and the infrastructure that makes further host-device optimizations possible in the future.

cllvmc+++3
Student: David Rivera
Code

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

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

compiler-rt builtins provide software floating-point routines (__addtf3, __multf3, __floatsitf, etc.) for targets that lack hardware FP support. The current implementations carry two problems. First, they are under-tested, and subtle bugs survive for years. PR#119449 shows one example: __floatdixf relies on the compiler to lower a cast, but the compiler implements that cast by calling __floatdixf, creating infinite recursion. Second, the codebase mixes C and hand-written assembly across architectures, which makes maintenance and extension to new types (_Float16, bfloat16) expensive. LLVM libc implements these same operations using formally verified building blocks (FPBits<T>, DyadicFloat<N>, BigInt<N>) with exhaustive test coverage. A recent refactoring effort (#147386) made these routines available as free-standing, header-only C++ utilities. This project replaces the legacy compiler-rt FP builtins with thin C++ wrappers that call into LLVM libc's verified routines, gated behind a CMake flag so the change is transparent and non-disruptive.

cllvmc+++3
Student: Mohamed Emad
Code

Friendlier Error Messages for Processing

beginner
Processing Foundation•2023Varies90h (Small)

This proposal entails revamping the existing Processing error message system so that it resembles the P5.js Friendly Error System (FES). The problem is that the current error messages are often vague and not easily understood by beginners. I plan to remedy this by ensuring each error message four components: the original error generated by the JVM, an identification of the problem an explanation of the problem and when possible, a solution to the error. The error messages should convey the severity of the error and in beginner friendly language, explain the cause of the error. The error message should also provide links to relevant documentation to contextualize the issues and also include the original JVM message. Time permitting, additional features such as translation into other languages, a log of previous errors and a button to accept user feedback.

pythonjavascriptandroid+6
Student: willybobilly
Code
Proposal

Messages scheduling

intermediate
rocket.chat•2025Varies175h (Medium)

Rocket.Chat users across multiple time zones need a way to schedule messages for optimal delivery, enhancing global collaboration. This project will implement a native message scheduling feature by integrating a scheduling UI, a cron job to send messages at the designated time, and a contextual bar UI to view and cancel scheduled messages. It will also support scheduling in threads, improve error handling, and include comprehensive documentation and unit tests. The deliverables include a MongoDB collection for scheduled messages, APIs (chat.scheduleMessage, chat.getScheduledMessages, chat.cancelScheduledMessage), a cron job (sendScheduledMessages), scheduling and viewing/canceling UIs, thread support, error handling, documentation, and tests

javascriptwebrtcmeteor.js+18
Student: Thotsem Jajo
Code
Proposal

Integration of Silicon Compiler Microservices into the TL-Verilog Mode in VS-Code

intermediate
Free and Open Source Silicon Foundation•2024Varies175h (Medium)

This project aims to enable the seamless integration of the Silicon Compiler's hardware design tools and flows within popular development environments like Visual Studio Code (VS Code). Silicon Compiler is an open-source, modular build system that automates the translation process from hardware design source code to silicon. It essentially serves as a "make for silicon," enabling developers to efficiently compile and synthesise hardware designs into silicon implementations. By leveraging the Silicon Compiler's microservices and developing a JavaScript API, users will be able to run various hardware design tasks, such as logic synthesis, place-and-route, static timing analysis, and simulation, directly from within their familiar coding environments. This integration will streamline the design process, improve productivity, and provide a seamless experience for developers working with Verilog or related hardware description languages (HDLs) within the editor. Instead of switching between different tools and environments, they can leverage the integrated functionality directly within VS Code, streamlining their workflow and improving productivity.

pythonjavascriptfpga+11
Student: Raj Aryan Singh
Code

Automated Compilation Verification Across All Concerto Code Generation Languages

intermediate
Accord Project•2026Varies175h (Medium)

Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.

javascriptreactcompiler+5
Student: Apoorv Gadiya
Code

Machine Learning Guided Ordering of Compiler Optimization Passes

advanced
LLVM Compiler Infrastructure•2021Varies350h (Large)

<p>Developers generally use standard optimization pipelines like -O2 and -O3 to optimize their code. Manually crafted heuristics are used to determine which optimization passes to select and how to order the execution of those passes. However, this process is not tailored for a particular application, or kind of application, as it is designed to perform “reasonably well” for any input.</p> <p>We want to improve the existing heuristics or replace the heuristics with machine learning-based models so that the LLVM compiler can provide a superior order of the passes customized per application.</p>

cllvmc+++3
Student: Tarindu Jayatilaka
Code
Proposal

Learner Diagnostic Tests

intermediate
Oppia Foundation•2022Varies175h (Medium)

Each learner that comes onto Oppia’s platform has a different level of experience and comprehension within a given subject and some of them have trouble identifying which topic they should start within the Oppia Classroom as a result, Learner Diagnostic Tests will allow the learner to test their knowledge and get a set of recommendations from where they should begin learning.

pythonjavascriptangularjs+10
Student: Nikhil_Agarwal
Code
Proposal

Improving user errors & Error Code Support for GCC Rust Frontend

intermediate
GNU Compiler Collection (GCC)•2023Varies175h (Medium)

The goal of this project is to enhance the user experience of gccrs by enabling it to emit error codes similar to rustc. This will help bridge the gap between the two test suites and eventually enable the rustc testsuite to run on gccrs. The project involves implementing necessary changes in gccrs to emit rustc error codes throughout its frontend code. Additionally, it entails expanding the code responsible for error emission to incorporate greater functionality. Furthermore, a comprehensive comparison between the rustc and gccrs test suites will be conducted to improve stability. The ultimate outcome will be an improved user experience for gccrs users, with an increased number of error emissions in various contexts and more informative hints on code resolution. By bringing gccrs closer to parity with rustc, this project aims to enhance its accessibility for users and developers alike.

cc++openmp+3
Student: Muhammad Mahad
Code

A user-defined run-time loadable module template for co-simulation with Chrono::Engine

advanced
MBDyn•2020Varies350h (Large)

<p>Due to increasingly complex coupling problems in engineer fields, it is significant to provide supports for co-simulation with other software in MBDyn. In this project, to achieve co-simulation with another open-source multibody software, Chrono::Engine (C::E), which has advantages in dealing with non-smooth multibody dynamics, a user-defined run-time loadable module is provided as a template. The template includes a module, applied to one or a cluster of nodes in MBDyn and receive forces resulting from objects in Chrono::Engine.</p>

pythonc++c/c++
Student: runsen Zhang
Code
Proposal

Message Forwarding

intermediate
rocket.chat•2022Varies175h (Medium)

Description: Implement the ability to forward messages to another channel, thread, or discussion. This is a high-demand capability that is currently missing in Rocket.Chat. It can significantly improve the user's experience and her/his productivity. The scope of this project will be limited to web applications and not to mobile apps. Deliverables: 1. Being able to forward messages and files to multiple users and rooms 2. Being able to add additional messages on top of forwarded content. 3. Being able to add text formatting in the optional message field. 4. Being able to provide a preview of the message before sharing it. 5. Ability to show “posted from this channel” below the forwarded message

javascriptwebrtcmeteor.js+18
Student: Nishant Patel
Code
Proposal

Sludge Engine

intermediate
ScummVM•2017Varies175h (Medium)

<p>SLUDGE is a 2D adventure game engine created during the development of the game "Out Of Order" by Hungry Software and my mission is to integrate this engine into ScummVM. As "Out Of Order" received "Game of the Year" awards from Adventure Gamers and The Crow's Nest in 2003, it will be quite favorable to add full support for this game as it is highly acclaimed and also, was released for free to showcase the SLUDGE engine. In addition, while testing games with the engine, a sound card initialization problem occurring occasionally has been noticed, I think it will be an advantage if we are able to fix it in ScummVM.</p>

openglc++assembly+5
Student: Simei YIN
Code
Proposal

Hyperledger - Solang Solidity Compiler optimizations and error handling Mentorship Project

Intermediate
•Varies175h (Medium)

Solang is a Solidity compiler that targets several blockchains, including Solana, Substrate and ewasm. The mentorship project consists of three goals that can provide mentees with a broad knowledge of a compiler's inner-workings. The three tasks are in different stages of the compiler. Solang’s parser analysis halts compilation entirely when there is any invalid expression or function declaration. This should be improved so that it continues parsing the Solidity contract after encountering an error, providing better diagnostics (warnings and errors) to the developer. The parser utilizes Lalrpop and the mentee would be using its error handling capabilities to implement a solution. Often the length of a dynamically allocated array is known at compile time as the allocation happens with a constant. When the length is required at some later point (e.g. for bounds checks for array indexing), the length is retrieved again. Mentees will add an optimization to make the length a compile time constant. Solang has an implementation of multiplication of integers of 256 and 128 bit. This does not have overflow detection. This requires improving the multiplication in the solang stdlib.

TBA
Proposal

Director Engine

intermediate
ScummVM•2021Varies175h (Medium)

<p>I'd like to continue my work on the Director engine from last summer, improving the engine so that it is production ready for some Director 2-4 games, as well as extending it to support Director 5 and higher.</p> <p>Again, my focus will likely be on Lingo, as well as implementing code to load and play Director 5 movies, and implementing major, missing non-Lingo features.</p>

openglc++assembly+5
Student: D.J. Servilla
Code
Proposal

SAGA2 engine

intermediate
ScummVM•2021Varies175h (Medium)

<p>Create a new engine to support Faery Tale Adventure II: Halls of the Dead by The Dreamers Guild.</p>

openglc++assembly+5
Student: a-yyg
Code
Proposal

Scaladex: Support for Compiler Plugins

intermediate
Scala Center•2025Varies175h (Medium)

Scaladex, the central index for open-source Scala libraries, currently does not have dedicated support for Scala compiler plugins—special artifacts used to extend or modify compiler behavior. These plugins are vital tools in the Scala ecosystem but are difficult to discover due to lack of indexing and classification. This project proposes adding full support for Scala compiler plugins in Scaladex. The implementation includes extending the binary version parser to recognize plugin naming conventions, adding a new platform type (CompilerPlugin), and integrating plugin-specific metadata into the indexing pipeline. The user interface will be updated to allow filtering and discovery of compiler plugins, and best practices for plugin authors will be documented. The key deliverables of this project include: Parsing and indexing improvements to recognize compiler plugin artifacts. UI enhancements for discoverability, including tags and platform filters. Updated documentation and contribution guidelines for plugin maintainers. A technical blog post summarizing design decisions, edge cases handled, and outcomes. By implementing these features, this project will significantly improve the visibility, discoverability, and usability of compiler plugins in the Scala community.

#scala#scala_lang#jvm+7
Student: Vidisha Gawas
Code
Proposal

Director Engine

intermediate
ScummVM•2020Varies175h (Medium)

<p>This project aims to improve ScummVM's existing Director engine so it can handle actual games, particularly Spaceship Warlock and The Journeyman Project, which was historically important in the development of Director and Macintosh gaming.</p> <p>The focus will be on improvements to the rendering pipeline, implementation of hundreds of missing Lingo features, and identification of unknown fields in the Director movie file format.</p>

openglc++assembly+5
Student: Dylan Servilla
Code
Proposal

Rust to .NET compiler - add support for compiling & running cargo tests

beginner
The Rust Foundation•2024$1.5k–$3.3k90h (Small)

This proposal aims to extend the ability of `rustc_codegen_clr`, the Rust to .NET compiler backend, to run `cargo test`s. While the project is already quite feature-rich, it still can't compile Rust tests properly. This project will focus on adding all the features necessary for such tests to run, with the end goal of running them within the .NET runtime. Adding those features will not only enable running tests, it will also improve the project, enabling it to compile far more Rust programs. At the end of GSoC, this project will deliver the following features: 1. Support for parsing command line arguments in Rust programs running within the .NET runtime. 2. Implementation of atomic intrinsics needed for `std` argument parsing to function properly. They should be implemented using cross-platform .NET APIs, but using architecture-specific functions may be needed to properly handle certain atomics. 3. Support for dynamic trait objects - creating them, dropping them, calling their member functions. 4. Support for catching panics, implemented using the .NET exception-handling primitives. 5. Support for multithreading: launching threads, and getting information about them. 6. Extended .NET interop, automatic creation of safe GC handles for managed objects. This feature is necessary for safely handling .NET threads, but will be exposed in the `mycorrhiza` interop layer, provided by the codegen. 7. Fixes to string formatting. This feature is necessary for reporting test results. At the end of this proposal, simple formatting, such as `format!("my string is:{string}")` should run within the .NET runtime. The end goal of this proposal is running a simple cargo test within the .NET runtime. This test will consist of two cases: one failing, and one passing. All the deliverables mentioned above are strictly needed for achieving that goal.

pythonrust
Student: Fractal Fir
Code
Proposal

Speech2Text Engine & Voice Recognition API Integration

intermediate
rocket.chat•2018Varies175h (Medium)

<p>Integrate an Open Source speech to text engine to be used inside Rocket.Chat by users who prefer an On-Premise full-featured installation. There are many opensource speech2text engines on the market, like CMUSphinx and pocketsphinxjs, annyang, JuliusJS, Mumble, Voix JS, voice-commands.js and Artyon.js. The project includes a feature matrix comparison between those engines and the best one to be implemented in Rocket.Chat bundle, giving the UI the ability to click a button, record a message, send it to the text2speech engine and return the results to Rocket.Chat editing message box.</p> <p>Develop a voice recognition integration feature, by building a Settings pane to connect some of the well-known voice recognition and speech to text APIs on the market directly from within Rocket.Chat. By configuring API’s connection and usage attributes, and giving rocket.chat’s UI the ability to click a button, record a message, send to the desired API and return the results to Rocket.Chat editing message box.</p>

javascriptwebrtcmeteor.js+18
Student: Karan Bedi
Code
Proposal

Build a Modern, Compiler-Integrated Kotlin Language Server

advanced
Kotlin Foundation•2025$6k–$13.2k350h (Large)

This project aims to build a high-performance, build-system agnostic Kotlin Language Server using the Kotlin Analysis API. The goal is to replace the unmaintained and inefficient open-source LSP with a modern implementation that supports the full LSP 3.17 spec, works across editors like VSCode and Neovim, and delivers IDE-grade language features like diagnostics, completions, and navigation without depending on kotlinc. By the end of GSoC, this project will provide Kotlin developers with a powerful alternative for writing and maintaining code outside JetBrains tooling.

gradlekotlinjvm+3
Student: Hemram
Code
Proposal
Showing 25 - 48 of 3883 Projects
12345
Proposal
Proposal
Proposal
Proposal
Proposal