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

Enhancements To Open Event Orga Application

advanced
FOSSASIA•2018Varies350h (Large)

<p>Open Event Orga Application is a client-side application for Open Event API designed for Event Organizers. The app provides functionality to Create Events, Create Tickets, Check In Attendee, Scan QR Code, Sales Overview, User Authentication etc.</p> <p>To further increase app's performance, user experience and expand its horizon, the following enhancements are proposed -</p> <p>● Migration to MVVM Architecture.</p> <p>● Background Job Scheduling for Offline Support.</p> <p>● Implementing various core modules comprising Orders, Sessions, Call for Speakers etc</p> <p>● Analytics and check-in/check-out functionalities.</p> <p>This will be accompanied by adding the required REST API and resolving bugs in Open Event Server project.</p> <p>Best available and tested technologies will be used to implement the above enhancements and test them thoroughly to achieve high-performance.</p>

pythonjavascriptandroid+7
Student: Priyanshu Khandelwal
Code
Proposal

Out of process execution for Clang-Repl

intermediate
LLVM Compiler Infrastructure•2024Varies175h (Medium)

Clang, part of LLVM, supports multiple languages and functions as a library, fostering a compiler-assisted ecosystem. Its accessible codebase and LLVM's JIT advancements enable innovative C++ processing methods, though challenges like incremental compilation and compile/link-time optimizations persist. Incremental compilation processes code in segments, building translation units and enabling efficient interpreters. Clang-Repl, using Orcv2 JIT within the same process, exemplifies this concept but faces limitations on resource-constrained devices and risks process-wide crashes on user code failure. This project aims to transition Clang-Repl from an in-process to an out-of-process execution model to address: 1. **Resource Constraints**: The current model requires substantial resources, limiting use on devices like Arduino Due. 2. **Crash Resilience**: In-process crashes can bring down the entire Clang-Repl process, affecting stability and user experience.

cllvmc+++3
Student: Sahil Patidar
Code
Proposal

MDAnalysis module to calculate membrane curvature

intermediate
MDAnalysis•2021Varies175h (Medium)

<p>Elements of differential geometry enable us to quantify the curvature of a surface. The core elements of biological membranes, phospholipids, provide tridimensional configurations from which a surface can be derived to calculate curvature descriptors. We would like to integrate to MDAnalysis an analysis module to calculate averaged mean and Gaussian curvature from Molecular Dynamics simulations. By integrating a membrane curvature analysis module in MDAnalysis, users will benefit from a tool that enables rapid extraction of relevant properties of lipid bilayers in biomolecular systems. Our approach extracts key elements of the membrane using phospholipid head groups to define a surface, followed by a transformation into NumPy arrays. In this way, the functionality offered by NumPy and SciPy can be used to derive values of mean and gaussian curvature of biological membranes. Since MDAnalysis already works very well to explore data interactively, visualization of the membrane curvature analysis outputs in 2D-maps can be easily performed.</p>

pythoncythonc/c+++1
Student: Estefania Barreto-Ojeda
Code
Proposal

Import System.IO.Pipes.PipeStream from CoreFX

intermediate
Mono Project•2017Varies175h (Medium)

<p>Mono is a open source development platform based on the <code>.Net Framework</code> and allows developers to build cross-platform applications. Mono's .NET implementation is based on the ECMA standards for <code>C#</code> and the <code>Common Language Infrastructure</code>. It includes both developer tools and the infrastructure needed to run .NET client and server applications on <code>Linux, Microsoft Windows, Mac OS X, BSD, Sun Solaris, Nintendo Wii, Sony PlayStation 3, Apple iPhone and Android</code>.</p> <p>The implementation of Pipe Streams in <code>Mono</code> doesn't support some functionalities such as parallel builds on msbuild. <code>CoreFX</code> is the foundational libraries for .NET Core. The implementation of Pipe Streams in CoreFx fixes the previous problems. So, the goal of the project was to import <code>System.IO.Pipes.PipeStream</code> from CoreFX to Mono. Doing this, new features are offered by Mono.</p>

cc#.net+1
Student: GEORGIOS ATHANASOPOULOS
Code
Proposal

Resonate-V4

advanced
AOSSIE•2026Varies350h (Large)

This project focuses on evolving Resonate into a more interactive, scalable, and maintainable real-time audio platform by introducing both feature-level enhancements and architectural improvements. Key user-facing features include chat-integrated polling, availability status, audio wave animations, interest-based discovery, and a gamified user stats system that provides meaningful reputation signals. These features aim to improve engagement, usability, and community interaction without compromising real-time performance. Alongside feature development, the project emphasizes core architectural modernization, including migrating from GetX to Riverpod, adopting a feature-based MVVM structure, decoupling business logic from UI, and optimizing the Appwrite backend. Additional improvements such as increased test coverage and recorded chapter management ensure long-term reliability and usability. Overall, the project balances product innovation with system scalability, transforming Resonate into a more robust and contributor-friendly platform.

pythonjavascriptswift+8
Student: Mayank4352
Code
Proposal

OWHF: Enhancing Indian Holidays: National and Subdivision Accuracy with Comprehensive Localization

intermediate
Python Software Foundation•2026Varies175h (Medium)

This project aims to improve the accuracy, completeness, and accessibility of Indian holidays in the Open World Holidays Framework (OWHF). It focuses on verifying and updating national and subdivision-level holidays using official government sources, ensuring consistency across all 28 states and 8 union territories. In addition, the project will expand localization support by providing holiday names in widely used Indian languages, making the framework more accessible to a broader user base. To enhance long-term consistency and maintainability of calendar-based holidays, the project will also introduce generator scripts for solar and lunisolar holidays. These scripts will be used to generate and validate holiday dates across extended year ranges, while keeping the runtime implementation lightweight and dependency-free. The final outcome will be a more accurate, fully localized, and scalable holiday dataset for India, aligned with real-world usage and the design principles of the holidays framework.

pythonmercurialjavascript+3
Student: ankushhKapoor
Code

Friendly Sketch Embedder for p5.js

beginner
Processing Foundation•2025Varies90h (Small)

Embedding p5.js sketches on different platforms can be tricky because some sites block scripts, remove iframes, or require a specific format. This project will create an easy-to-use embed generator that lets users customize their embeds without writing any code. It will support both Global and Instance Mode, making it flexible for different coding styles. Users can adjust the size, background color, playback options, and whether the code is editable or locked, all through a simple interface. To make things even easier, the tool will include smart platform presets, so users can generate the right embed code for platforms like WordPress, Medium, Notion, and static site builders. A live preview will show exactly how the embed will look before copying the code. This project will remove technical barriers, making it simple for teachers, artists, and developers to share p5.js sketches anywhere.

pythonjavascriptandroid+6
Student: Nwakaego Glory
Code
Proposal

Parameter estimation for nonlinear dynamical models.

intermediate
NumFOCUS•2018Varies175h (Medium)

<p>A differential equation model of a dynamical system is a nonlinear parameterized model that is created to match realistic scenarios and occasionally it might be associated with some data, obtained from the system or through simulation. Once there is reasonable level of confidence in the correctness of the model, the task that remains is to estimate the parameters of the model. Due to the structure of parameter estimation problems in dynamical models, statistics and machine learning techniques are an ideal choice for determining the parameters. During the course of the summer I will be implementing some statistical algorithms, including Stochastic Approximation Expectation Maximization(SAEM) and Maximum A Posteriori Estimation (MAP), for parameter estimation of a dynamic model. I will also work on extending support for parameter estimation in Stochastic Differential Equations (SDEs) by adding first differences distribution to generalized Log-Likelihood. These would be quite important additions to the suite of methods in JuliaDiffEq and would be of great use to scientific community involved in systems biology, HIV-AIDS study, and drug dosage estimation.</p>

pythonjavascriptr+3
Student: Vaibhav Dixit
Code
Proposal

The collective power of multiple communities: Integrating the Empurrando Juntas API with Decidim

intermediate
LAPPIS•2024Varies175h (Medium)

This project aims to integrate two civic participation platforms, Empurrando Juntas (EJ) and Decidim. EJ collects user opinions on specific topics, clusters similar views, and enables the identification of echo chambers, a feature often overlooked by traditional tools. Decidim, however, is designed to support public consultations, deliberative processes, and collaborative decision-making. By allowing Decidim users to access and contribute to EJ’s features, this integration will facilitate collaboration between communities and enhance the reach and impact of both platforms, leading to more inclusive and effective civic participation. The integration will involve developing a gem to modularize the code and streamline the connection between the two platforms. This gem will incorporate EJ's functionality into the Decidim environment. Furthermore, we will integrate request and response mechanisms to enable Decidim to seamlessly access and showcase pertinent information from EJ within its interface; as a result, it will offer users a more cohesive and enriched experience.

pythonmachine learningruby on rails+1
Student: Yan S. Guimarães
Code

Improve and Polish the Generation of Structures of Combinatorial Species

intermediate
SageMath•2026Varies175h (Medium)

SageMath's LazyCombinatorialSpecies framework (sage/rings/lazy_species.py) represents combinatorial species as lazy sequences of symmetric-group actions and supports molecular decompositions, generating series, and structure enumeration. Recent work in PR #41655 adds the Hadamard product, functorial composition, and arithmetic product at the level of molecular data, but these operations lack structure generation. The derivative operation is also missing entirely. This project will: (a) implement the derivative and multisort partial derivatives, with cycle index, generating series, and pointing methods (b) extend the Hadamard product and functorial composition to multisort species (c) systematically verify that weights propagate correctly across all operations (d) implement structures() and isotypes() methods for the derivative, Hadamard product, functorial composition, and (time permitting) the arithmetic product. Every new method will be verified against the existing _test_structures consistency checks. The project concludes with full documentation and a pull request.

pythoncython
Student: Parth Chavan
Code
Proposal

AI Chatbot to Guide User Workflow

advanced
Jenkins•2026Varies350h (Large)

While Jenkins is the backbone of modern CI/CD, troubleshooting failed builds and complex configurations remains a time-consuming bottleneck. This project develops a Diagnostic AI Chatbot plugin to drastically reduce this friction, minimizing debugging time and maximizing developer productivity. Powered by an advanced Retrieval-Augmented Generation (RAG) architecture, the agent leverages LangGraph and hybrid search to intelligently filter noisy build logs, cross-referencing them with official documentation and community discussions in order to deliver precise root-cause analysis and actionable fixes. Architecturally, it utilizes a decoupled FastAPI backend, ensuring zero computational overhead on the Jenkins Controller. The system is highly flexible: it is designed with a privacy-first approach optimized for local open-source LLMs, while seamlessly supporting integration with third-party commercial APIs. This allows administrators to effortlessly toggle between absolute data privacy and frontier model performance based on their infrastructure needs.

javascriptjavago+2
Student: Daniele Caldarigi
Code
Proposal

instrument OpenTracing with go-restful web framework

intermediate
Cloud Native Computing Foundation (CNCF)•2017Varies175h (Medium)

<p><code>go-restful</code>(<a href="https://github.com/emicklei/go-restful)is" target="_blank">https://github.com/emicklei/go-restful)is</a> a widely-used library for building REST-style Web Services using Google Go. With powerful built-in modules including intelligent request routing, RESTful support and filters for intercepting HTTP request, go-restful make it very convenient to build a web application from scratch. This proposal aims at instrumenting OpenTracing with go-restful.</p> <p>With OpenTracing instrumentation, go-restful web app developers can add (or switch) tracing implementations with an O(1) configuration change. More important, because OpenTracing is instrumented at go-restful library, a low enough level in the software stack, even large web application could be traced without additional annotations, application programmers also does not need to be aware of the tracing system.</p>

prometheusgokubernetes+7
Student: MINGQIANG LIANG
Code

Refactor Casbin.js and other optimizations on pycasbin and node-casbin

intermediate
Casbin•2021$3k–$6.6k175h (Medium)

<p>In the last GSoC, kingiw created an initial version of casbin.js. This version has a CASL-like API. He also adds support to go-casbin and node-casbin.</p> <p>However, casbin.js relies on an insufficient way to share permissions between the frontend and backend. The backend needs to send the whole policy definition model to the frontend, which will use node-casbin to check the permission. This method requires a heavy data transfer in between, and has potential security problems.</p> <p>To build a production-ready frontend permission control library, we need to</p> <ul> <li>Design a new data structure to only store one-user permission.</li> <li>Add a full set of API to operate on the data structure.</li> <li>Implement integration with the frontend frameworks like React or Vue.js.</li> <li>Add util function in different implementations of Casbin.</li> </ul>

pythonjavascriptgo+7
Student: Xinyu Zhou
Code

Benchmarking and Profiling in toqito

advanced
NumFOCUS•2025Varies350h (Large)

This project aims to test the performance of |toqito⟩ and compare it with other quantum computing libraries. It is divided into three parts: (1) Comparing |toqito⟩ with libraries like PennyLane, Qiskit, etc. by running standardized tests inside Docker to ensure consistency across different computers; (2) Automatic benchmarking using GitHub Actions, where performance tests run on every update and results are stored for analysis; and (3) Identifying slow parts of |toqito⟩ using cProfile, focusing on operations like matrix calculations, quantum measurements, and random object generation. ------------------------------------------------------------------------------ Deliverables include: 1. A new benchmark/ folder in |toqito⟩ that can run and store benchmarks, including support for running them in Docker. 2. A system to track |toqito⟩’s performance over time using monthly benchmarks or we can choose to run only relevant benchmarks after each merged PR. 3. Found and suggested improvements for slow parts in at least one full module of |toqito⟩.

pythonjavascriptr+3
Student: justuy
Code
Proposal

ASL Parameters Generator from DICOM/ BIDS Images

beginner
Open Science Initiative for Perfusion Imaging•2025Varies90h (Small)

This project aims to develop a modular, open-source Python package and a web app built on it to automatically extract acquisition parameters from ASL MRI datasets in DICOM and BIDS formats and generate standardized methods sections for scientific publications. Manual reporting of MRI parameters is often time-consuming and error-prone, hindering reproducibility. This tool addresses the issue by extracting metadata, including hidden and private DICOM tags, while interactively prompting users for any missing parameters to ensure completeness. It will feature an improved DICOM/BIDS handler, an interactive graphical user interface (GUI) for parameter input and validation, and comprehensive documentation. It will also undergo beta testing with OSIPI TF4.1 members. Designed for easy integration with future extensions such as DSC/DCE MRI support, the tool will enhance transparency, save researchers valuable time, and contribute to strengthening OSIPI’s ecosystem for perfusion imaging.

pythongithub
Student: Ibrahim Abdelazim
Code
Proposal

Improving the AOSSIE Scholar Extension

intermediate
AOSSIE•2022Varies175h (Medium)

The project proposal aims at enhancing and upgrading the features and functionalities of the extension. However, some of the new issues came across that need to be addressed such as the expiration of manifest v2, an empty Django backend page, and single-browser supportability. I plan on improving the UI so that it will become more innovative and user-friendly, injecting the button feature in the Google Scholar page for direct navigation to an author's profile page, integrating extension with typescript, adding cross-browser compatibility and new metrics indexes, transitioning chrome extension to manifest v3, and providing dark mode and an option to toggle between light and dark themes. I also plan to make the codebase more polished by replacing javascript dom functions with jQuery and creating a login/signup page for enrolling new users. Besides this, I will also be maintaining detailed documentation on CI/CD integration testing, gulp automation workflow, and various test cases for making it useful to the new developers.

pythonjavascriptswift+8
Student: Subhangi Choudhary
Code
Proposal

Chord Symbol Improvements

intermediate
MuseScore•2019Varies175h (Medium)

<p>MuseScore currently supports playback for a majority of their elements. Chord Symbols, however, are purely visual and lack playback. When writing or arranging lead sheets, this can be an issue as the chord symbols detail the entire harmony of the piece. Additionally, others users may want to notate partial ideas or a skeleton of an idea that’s most easily represented with chord symbols. In these cases, this means that a user would only be able to hear a preview of the melody and nothing else. Unless the user is an experienced professional with strong audiation skills, being unable to physical hear the harmony of their music is an important setback.</p> <p>This project aims to implement the playback of chord symbols in a flexible way to suit different styles and genres of music and be versatile for use with final scores as well as unfinished drafts. Completion of this project will allow users to work with greater efficiency and enhanced feedback on their scores as well as set up MuseScore for additional development in harmony.</p>

c/c++qtqml+7
Student: Peter Vu
Code
Proposal

Modernizing radiospectra: A Coordinate-Aware and Interoperable Spectral Data Framework

advanced
OpenAstronomy•2026Varies350h (Large)

Current radiospectra stores spectral data as plain NumPy arrays with each instrument client handling metadata, axis ordering and coordinate conversions differently. This leads to inconsistencies and requires users to write boilerplate code for common tasks such as slicing by time or frequency, performing background subtraction and working with physical coordinates. It also limits integration with SunPy's coordinate-aware ecosystem like NDCube and WCS. This project proposes developing a single Spectra class that provides a consistent, high-level interface for radio spectrogram data. The class will support intuitive slicing using physical coordinates, built-in background subtraction and simplified visualisation while abstracting underlying array complexities. The project will explore integrating NDCube or alternative approaches such as xarray or a custom WCS layer to ensure the best fit. The goal is to make radiospectra as user-friendly and consistent as sunpy.map, improving usability and interoperability across the SunPy ecosystem.

cpythonjulia+7
Student: Kumar Amityush
Code

Enable Modules on Windows

advanced
CERN-HSF•2020Varies350h (Large)

<p>ROOT has several features that interact with libraries and require implicit header inclusion. This can be triggered by reading or writing data on disk, or user actions at the prompt. Exposing the full shared library descriptors to the interpreter at runtime translates into an increased memory footprint. ROOT’s exploratory programming concepts allow implicit and explicit runtime shared library loading. It requires the interpreter to load the library descriptor. Re-parsing of descriptors’ content has a noticeable effect on runtime performance. C++ Modules are designed to minimize the reparsing of the same header content by providing an efficient on-disk representation of the C++ Code. C++ Modules have been implemented for Unix and OS X systems already and it is expected that with next release of ROOT, C++ modules will be default on OS X. This project aims to extend the C++ Modules support for Windows, by implementing compatible solutions to the UNIX baseline and also display corresponding performance results.</p>

pythonc/c++machine learning+6
Student: Vaibhav Garg
Code
Proposal

Interface the database search engine to an AI-based LLM

advanced
KDE Community•2026Varies350h (Large)

DigiKam’s Advanced Search is powerful, but translating a natural-language request into the right combination of structured filters can be difficult for many users. This project will add a natural-language input to digiKam’s Advanced Search so users can describe queries such as “landscape photos with red labels taken in Paris last summer,” which will then be converted into editable search criteria such as tags, labels, dates, and locations. The implementation will use a lightweight local language model, structured intent parsing, capability-based resolution into supported digiKam search fields, ambiguity handling for unclear terms, and caching for repeated queries, while reusing digiKam’s existing model-management infrastructure. The deliverables include the Advanced Search UI integration, the local inference and parsing pipeline, criteria resolution and validation, safe clarification behavior, and end-to-end integration with digiKam’s existing Advanced Search workflow.

c/c++qtqml+6
Student: Srirupa Datta
Code
Proposal

Improved Console Output for Swift Testing

intermediate
Swift•2025$3k–$6.6k175h (Medium)

This project enhances the console output experience for the Swift Testing framework by designing and implementing a new, two-phase console reporter. This architecture provides both real-time feedback during test execution (the "Live Phase") and concludes with a comprehensive, structured report (the "Summary Phase"). The primary focus during this GSoC project was the implementation of the Summary Phase, which includes: - A rich Hierarchical Summary that visualizes the relationship between test suites and individual tests. - A dedicated Detailed Failure Report providing clear, actionable information for debugging. - Intelligent cross-platform support, with an ASCII fallback for terminals with limited Unicode compatibility. Architecturally, the reporter was refactored to consume a serialization-based event stream (ABI.EncodedEvent). This was a significant technical pivot that decouples the reporter from the test runner, preparing it for future integration into an out-of-process "harness". The final deliverable is a robust, experimental implementation available behind a feature flag, with a clear roadmap for completing the Live Phase post-GSoC.

llvmc++cmake+5
Student: Tien Quoc Bui
Code
Proposal

VLC Qt interface redesign

intermediate
VideoLAN•2021Varies175h (Medium)

<p>The VideoLAN organisation has transformed the digital audio and media space since its inception over 10 years ago. The ease of use of its forerunning product, VLC Media Player, has made it the number one choice for millions of users around the world for viewing and interacting with media. Yet, despite this VLC Media Player’s design is relatively outdated. Features should be readily obvious to users, not hidden in multiple menus so that they can be accessed quickly and easily.</p> <p>As an avid VLC Media Player fan, this forms the motivation behind my proposal. I propose to update VLC Media Player by leveraging Qt/QML to design a more modern and elegant interface. Specifically, I plan to redesign and implement a new welcome screen which is visible upon first opening of VLC Media Player. This includes the relevant Privacy and Metadata Consent passages for users as well as the ability to alter some commonly changed settings through an easily accessible modal.</p>

copenglc+++10
Student: Adam Leung
Code
Proposal

PyGoat v3 – Microservices, Labs, and Learning Paths

intermediate
OWASP Foundation•2026Varies175h (Medium)

This proposal outlines modernization of Pygoat, focusing on scalability and a future-proof curriculum. The top priority is a complete structural and gamified overhaul, featuring a dynamic scoring system and a lab list updated for OWASP Top 10:2026. This is supported by a new Core API Gateway and a Dynamic Admin Control Center, which together allow for seamless, real-time monitoring of dockerized labs and centralized management of user data and security categories. A key innovation is the Plugin-Based Custom Lab Loader, allowing the community to integrate their own labs via a standardized labs.json format. To ensure long-term accessibility, the project includes a Tailwind CSS UI migration, automated CI/CD pipelines for multi-platform Docker builds, and a comprehensive MkDocs documentation hub. By bridging the gap between exploiting a vulnerability and implementing secure coding practices, these features provide a structured, professional, and engaging learning path for the new security developers.

pythonjavascriptjava+10
Student: samyak003
Code
Proposal
Showing 4177 - 4200 of 4718 Projects
173174175176177
Proposal
Proposal
Proposal
Proposal
Proposal