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
5976 Projects Found
Sort by

Cloth Simulator Improvement

intermediate
Blender Foundation•2019Varies

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>Blender has had a cloth simulator for quite a while now. It is based on a system that now needs major changes. A lot of research has been done in adaptive cloth simulation (which is the next big step towards being able to do realistic cloth simulation in reasonable computation time). By introducing adaptive cloth simulation into Blender, we can decrease the computation time per frame, thereby leading to a better quality of simulation in the same amount of time. Furthermore, it would then be possible to build really powerful cloth production pipelines. The current cloth production pipeline is slow and requires a lot of user interaction (for example, for adding the correct level of topology and redefining the stitches each time the topology changes). With the introduction of adaptive cloth simulation, the algorithm can automatically determine the necessary topology to get the correct collisions and realistic folds and wrinkles. Additionally, this project would act as the base for future improvements, such as adding contact friction and dynamic tearing of cloth.</p>

cpythonopengl+3
Student: Ish Hitesh Bosamiya
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

Causeway / Improving the Core Infrastructure and Experience , Mentor David Lee

advanced
UC OSPO•2024Varies350h (Large)

The proposed project aims to enhance the platform by integrating logging and analytics features, implementing a learning dashboard, potentially introducing new modules for database management, and conducting usability studies for future open-sourcing. Responsibilities include implementing various login options like Google, GitHub, email/password, and passwordless login using Firebase Authentication, enhancing the landing page with an about section and improved UI design, introducing quizzes after each section using Firebase Firestore and Cloud Functions, developing user and learning dashboards with Angular Material UI and Firebase Cloud Functions, improving overall UI design and including walkthroughs for application implementation, providing an introductory demo for new users, integrating Vercel Bot for automation of deployment and monitoring processes, and including contact and feedback options for user inquiries. This comprehensive approach aims to modernize the platform, enhance user engagement, and improve usability for an optimized learning experience.

pythonc/c++visualization+5
Student: Rishi Mondal
Code

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

Input method in FreeBSD virtual terminal

beginner
The FreeBSD Project•2021Varies90h (Small)

<p>Currently, the FreeBSD virtual terminal driver vt(4) does not support inputting CJK characters directly in the virtual terminal, so our project idea is to provide an environment that can run IME (input method editor) in the console.</p> <p>A common usage scenario is when a user wants to create a user with the user info description in Chinese during the system installation. Since the installation process must proceed in a virtual console, there is no way to open an IME window to input CJK characters.</p> <p>Another example is hosting a FreeBSD server on a cloud platform or a virtual machine. When one wants to do some simple admin routines on the machine or disconnects from the SSH session, he/she needs to do some configurations and keeps records or takes notes on the server. It's sometimes quite inconvenient for those CJK writing-system users to write texts in their most familiar languages.</p> <p>And we want to implement similar features of those IME (fcitx, ibus) but in the console.</p>

c/c++llvmassembly+5
Student: Fan Chung
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

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

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

Implementing Chebyshev polynomial approximations in Haskell: Having the speed and precision of numerics with complex, non-polynomial functions.

advanced
Haskell.org•2019Varies350h (Large)

<p>Practically speaking, in science, engineering, and statistics, most computations are done numerically. My project aims to implement a library that can solve for Chebyshev polynomials. For complex mathematical functions, Chebyshev polynomials allow us to compute perform operations such as differentiation, integration, and solutions of ODEs with both greater speed and the same numeric accuracy as when dealing with the original functions. In this project, I hope to implement a Chebyshev polynomials module, along with the appropriate documentation, residual functions to validate the approximations, and test cases. The functions associated with the Chebyshev polynomials will be able to be used alongside the rest of the existing hmatrix library. I will also integrate the Accelerate language, an embedded language built to allow high-performance parallel arrays for Haskell. This library naturally fits into this project, because it allows for quick computations on large multi-dimensional arrays. Numerical algorithms are often used to solve large systems of equations, that are easily converted into large matrices of data.</p>

haskellghccabal+3
Student: Deifilia To
Code

Add a Print this component to O3

intermediate
OpenMRS•2023Varies175h (Medium)

While the Open Medical Record System (OpenMRS)'s major objective is to store and retrieve electronic medical records in the developing world, in some areas this objective has been frustrated due to lack of a stable internet connection, tech-illetracy and rampant power outages in most parts of the developing world. A patient's medical history and treatment may be well documented but due to lack of internet, computers and electricity in the next facility, that patient may not be in position to receive the service due to lack of reference document hence breaking continuity of care among health care providers, its is against this background that the print feature was development. so that at any point in time, a patient and the service provider can have a hard copy of whichever document they want. how I plan to solve it; 1. have a list of areas where printing is required and add them to the configurations 2. Add the print button in the selected areas 3. write code for the print function using the react-to-print package 4. write tests

javahtml5groovy+11
Student: Deb
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

SCIM 2.0 Compliance Test Suite

intermediate
WSO2•2017Varies175h (Medium)

<p>The proposal is on implementing the SCIM 2.0 compliance test suite which can be run on both the cloud and on premise by eliminating the limitations that can be seen in SCIM 1.1 compliance test suite. In the proposed test suite, it is expected to validate the supportability of a provided service provider, in terms of the SCIM 2.0 core specification and protocol specification.</p> <p>The test suite should be able to generate a detailed analysis view and comprehensive report upon providing the server’s SCIM endpoint. The report should include the test results indicating the coverage percentage of each specification and a detailed view of the results of each test including requests sent by the test suite, expected response and the server response along with the indication whether a particular test is passed or not.</p> <p>Apart from that the test suite should be run against WSO2 Identity Server to identify any gaps between the SCIM 2.0 specifications and Identity Server and provide improvements to the product.</p>

javaweb servicesmiddleware+2
Student: Vindula Jayawardana
Code
Proposal

Resonate - A Social Voice Platform

intermediate
AOSSIE•2023Varies175h (Medium)

The objective is to develop an open-source, social voice platform that promotes collaboration and community engagement. To achieve this objective, the project architecture involves the development of a Flutter App and a NodeJs + Express Server, both powered by the Appwrite backend. By integrating Appwrite, the platform will benefit from its robust features and functionalities, replacing the previously planned Firebase backend. The Flutter App will serve as the primary user interface, offering a seamless and intuitive experience for users. The Node.js + Express Server will handle the backend logic, providing essential APIs for communication with the Appwrite backend. This integration will enable efficient management of rooms/spaces and storage of user-generated content. Additionally, the project will leverage Livekit, an open-source WebRTC Stack, to provide real-time audio communication infrastructure. By incorporating Livekit into the platform, users will have the means to engage in live discussions, enabling effective collaboration and fostering a sense of community.

pythonjavascriptswift+8
Student: Chandan S Gowda
Code
Proposal

Android lint infrastructure and fixes

intermediate
Oppia Foundation•2025Varies175h (Medium)

The Android build ecosystem includes a robust linting tool designed to detect Android-specific issues that general-purpose linters may overlook. Currently, Android Lint is not integrated into Oppia's Bazel-based build system. This project aims to bridge that gap by introducing a custom linting script that runs Android Lint independently of Gradle, with support for configurable exemptions via textproto files—ensuring alignment with Oppia’s existing scripting infrastructure. The project will proceed in two phases. The first will establish a foundational script that interfaces with Android Lint, handles exemption logic, and integrates with continuous integration workflows. The second will focus on resolving high-priority lint issues to improve overall code quality. The completed project will deliver a scalable and maintainable Android linting workflow tailored to the Bazel environment, enhancing code quality and developer productivity across the Oppia Android codebase.

pythonjavascriptangularjs+10
Student: manas-yu
Code
Proposal

Hardware Abstraction Layer Transitional Library for Software to Hardware Posits For RISC-V Mentorship Project

Intermediate
•Varies175h (Medium)

This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.

TBA
Proposal

Agora Android

advanced
AOSSIE•2021Varies350h (Large)

<p>Agora Android application runs smoothly and works fine with all the functionalities. This summer I am planning to add a Welcome screen for the new users and use the spotlight feature to guide all the new users with every feature in the app. The major fix will be memory leaks, which hinder a lot in the performance of the application. I am going to enable deep linking and allow users to vote through the app itself. Adding a search bar to search elections is on my to-do list. Manually adding every voter and candidate can be hectic for a large list, so I plan to make it easier by importing these data from excel sheets. I will be adding more visualization techniques in Result Fragment and also export the result in excel format to external apps or share it as a png file. I will connect the application to Firebase, and enable crashlytics, analytics, and Firebase Cloud Messaging for better app retention. In addition to this, I am planning on multi-theme support and writing unit tests for all the business logic implemented.</p>

pythonjavascriptswift+8
Student: Divyank Lunkad
Code
Proposal

Boost.Real project

beginner
Boost C++ Libraries•2018Varies90h (Small)

<p>In the history of Computer Science, real numbers representation and data structures do not have a simple solution, numerical errors can be carried from one operation to the next and after several steps, the error may significantly increase. Also, irrational numbers representation as the number π or e^π are not handled by the native number data types and causing limitations when calculations are based on those numbers. The problem can be summarized as: there are an infinite amount of different numbers and a finite representation system. Even if there are some existing solutions, there is not a modern C++ open source library to attack the problem and Boost C++ could be the appropriated place.</p> <p>Following the Real number representation introduced in chapter 2 of Oliver Aberth. Computable Calculus. Academic Press, 2001. I propose to implement a data type to represent Real numbers and to define the operators (+, -, *, /, !=, &lt;, &gt;, =). This data type attacks the introduced problem and allows to represent some calculable real numbers as π</p>

c++c++11c++14+3
Student: Laouen Belloli
Code
Proposal

Improve Diff Handling

intermediate
coala•2019Varies175h (Medium)

<p>I aim to improve the existing diff handling capability of coala so that it is possible for bears to offer multiple fixes for an issue. I also plan to implement interactive diff behavior where the user input is used to generate interactive diffs using appropriate placeholders in the code. For achieving this I plan to have a generic approach for bears to pass their own applicable actions which can then be used to write a generic bear which can offer multiple patches. This can be followed by Implementation for templated patches and interactive diff behavior along with writing tests supporting these new functionalities. Finally thorough testing and exception handling should be done to fix bugs and designing alternate approaches if necessary(e.g. resolve conflicts of multiple bears on a single issue by git like conflict markers through IDE). I would be updating the documentation throughout the project. An optional task would be implementing output formats for the enhanced features and their processing functions being implemented in the Linter class if time permits.</p>

pythondjangopython 3+7
Student: Utkarsh1308
Code
Proposal

Object Detection on Point Cloud Streams

advanced
Society for Arts and Technology (SAT)•2025Varies350h (Large)

This project comprises two parts: prototyping a real-time Python pipeline for object detection on point cloud data, and integrating it into LivePose. The goal is to build a functional pipeline that reads streaming point cloud data from various sources (e.g., Orbbec Femto Megas, Intel RealSense, stereo cameras), runs deep learning inference using models like PointNet++, applies filters for smoothing and tracking, and streams the results via OSC. During prototyping, the system will be evaluated across multiple models, input types, and hardware configurations to assess real-time performance and reliability. Once validated, the pipeline will be integrated into LivePose, leveraging its modular infrastructure for input handling, filtering, and output. By the end of the project, LivePose will support end-to-end processing of streaming 3D point cloud data in at least one working configuration, with clear documentation and performance benchmarks to guide future development and extension.

pythonjavascriptopengl+4
Student: Eddie Liu
Code

Bivariate Colormaps

intermediate
NumFOCUS•2024Varies175h (Medium)

Multivariate data visualization is useful when grappling with correlated data that naturally arises in a number of scientific fields, such as polarization microscopy, hyperspectral astronomy, various X-ray imaging techniques, geographical data, etc. While specialized and/or commercial tools exist in some of these disciplines, implementing support for multivariate color mapping in matplotlib would provide a unified framework and expand access across the various use cases. This feature has been proposed multiple times, but implementation is non-trivial as it affects the low-level classes that handle data normalization. A discussion on GitHub led me to develop a solution where the class ScalarMappable is replaced by VectorMappable. I have already demonstrated the feasibility of this approach, and developed a working implementation, including a test suite for the new functionality. This project aims to finish this implementation by creating tutorials, examples, and presenting color maps for various use cases. Additionally, tests, docstrings, variable names, and code organization must be updated to conform to the quality standards of matplotlib.

pythonjavascriptr+3
Student: trygvrad
Code
Proposal

Gradually Typed Hasktorch

intermediate
Haskell.org•2021Varies175h (Medium)

<p>Hasktorch has two distinct APIs for tensors: Torch.Tensor and Torch.Tensor.Typed. While the untyped version can initially be easier to use and experiment with, the typed version offers static analysis of tensor’s shape, layout, precision, and compute device. The typed version not only helps with debugging and maintainability but also offers better support for type-driven development via GHC features like type holes. However, it is currently difficult to mix the two approaches, e.g., statically specifying tensor’s embedding size while keeping other dimensions unchecked is not possible. Gradual typing is the proposed solution that fuses the two APIs by adding Torch.GraduallyTyped type. The new API allows for more granular control by letting the user choose which properties of the tensor should be given a static type. The goal of the project is to bring maturity to the gradually typed tensor API, add missing features, and experiment with new ideas.</p>

haskellghccabal+3
Student: Julius Marozas
Code
Proposal

Enhance statistical inference using linear regression in MNE-Python

advanced
Python Software Foundation•2019$6k–$13.2k350h (Large)

<p>In statistics, linear regression is typically used for modelling relationships between predictor variables and a response variable. In particular, by determining the strength of the relationship between predictors and response variables, linear regression algorithms can explain variation in the response variable, which can be attributed to variation in the predictors, allowing the identification of variables and/or subsets of data that contain relevant information about the response variable. To date, linear regression functionality in the premier toolbox for analysing neural time series in Python, MNE, is capable of handling designs mostly characterised by the introduction of categorical predictors, to explain variation in brain activity, based on ordinary least squares estimation. The goal of the GSoC project is to extend the functionality and inference options of the linear regression module in MNE-Python by providing a set of functions for specifying and testing more complex variants of the linear regression framework, that are commonly used by the neuroscience community. In addition, the project aims at validating these tools on open data resources.</p>

pythonmercurialjavascript+3
Student: José C. García Alanis
Code

Improving User Testing with Eye Tracking, Sentiment Analysis & Pre/Post Tasks

intermediate
Uramaki LAB•2025Varies175h (Medium)

This project aims to enhance RUXAILAB, an open-source platform for usability evaluation, by integrating three key components: eye tracking, sentiment analysis, and pre/post form tasks. These additions will support real-time, data-rich user testing and improve the understanding of user behavior and emotional responses. We will embed affordable eye tracking to visualize attention (e.g., heatmaps, gaze paths), implement multimodal sentiment analysis using facial expression recognition and NLP, and enable customizable pre/post-test forms to evaluate usability (e.g., SUS, NASA-TLX) and cognitive load. Built with a user-centered, modular, and API-first approach, the project will also define evaluation protocols, publish open datasets, and validate the system with real users. The outcome will be a comprehensive, extensible, and community-driven tool for empirical UX research, bridging qualitative and quantitative insights.

pythonjavascripthtml+2
Student: João Franzoni
Code
Showing 5425 - 5448 of 5976 Projects
225226227228229
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal