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

Asynchronous lifecycle events for storage objects

intermediate
libvirt•2016Varies

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>The purpose of the project is to implement asynchronous lifecycle events for libvirt’s storage API. Lifecycle events allow applications to get notifications about the state of the object, as well as for object creation, deletion etc, without having to pull libvirt at regular intervals asking for the state of the VM. This implementation will also include adding support to virt-manager for storage events. Also, part of the project is extending event-test.py from libvirt-python to watch for storage events and print messages about them, as well as add asynchronous event support for nodedev objects. Also extending the python API for the implementation in virt-manager and libvirt-python. After the implementation of the storage API, project includes implementation of asynchronous event support for nodedev objects, followed by extending the python API, implementation in virt-manager and in libvirt-python. When this part is finished, I'll continue working on nodedev, and add event support for udev and netcf drivers.</p>

cxenqemu+6
Student: gulic
Code
Proposal

Integrating RRPlugins with libRoadRunner

advanced
National Resource for Network Biology (NRNB)•2020Varies350h (Large)

<p>LibRoadrunner is a high-performance SBML based simulator that uses LLVM to generate very efficient runtime code. This enables LibRoadrunner to simulate models on par with compiled C/C++ code. By combining Libroadrunner with standard optimization algorithms it is possible to use Libroadrunner to fit models to data. At present this is done by writing code to link the standard Python optimizers available via scipy with libroadrunner. Although this works it is inefficient and for large models, it is not practical. In this project, we would like to continue the work to develop a C/C++ based optimization plugins that can be used directly by LibRoadrunner with the help of RRPlugins. RRPlugins is a software that uses Libroadrunner as a dependency to load plugins and perform optimization tasks. Now if we build roadrunner we need to build plugins again since plugins are designed in such a way that they use LibRoadRunner and RRPlugins both as a dependency. To overcome this we decided to integrate both LibRoadRunner and RRPlugins and this would enable us to provide high-performance optimization capabilities.</p>

pythonjavascriptjava+11
Student: Debashish Roy
Code

Various SQL VM improvements: threaded interpretation and instruction merging

intermediate
Tarantool•2021Varies175h (Medium)

<p>Tarantool uses SQL VM with conventional interpretation technique: loop over instruction, inside which dispatching switch-case executes logic of current opcode. Beyond introduction of JIT to SQL subsystem there are multiple smaller improvements which might be developed for SQL virtual machine:</p> <ul> <li>merge CHECKs bytecode into a monolithic program;</li> <li>add VDBE assembler;</li> <li>use threaded interpretation. The easiest approach in its implementation is 'threaded-code'. Threaded code is a programming technique where the code has a form that essentially consists entirely of calls to subroutines. It is often used in compilers, which may generate code in that form or be implemented in that form themselves. The code may be processed by an interpreter or it may simply be a sequence of machine code call instructions. Another optimization is instruction merging: a sequence of opcodes is replaced by a single mega opcode. There is a proposal to create a single VDBE running all the CHECK constraints.</li> </ul>

cluasql+2
Student: Anastasia Neklepaeva
Code

Enhancing the Knative func CLI Experience (2025 Term 3)

Intermediate
•Varies175h (Medium)

Knative Functions enables you to easily create, build, and deploy stateless, event-driven functions as Knative Services by using the func CLI. With this LFX project, we aim to conduct a comprehensive UX evaluation of the func CLI. The focus will be on identifying usability issues, understanding developer workflows, and gathering structured feedback on CLI interactions. The findings will help improve the CLI's intuitiveness, efficiency, and user satisfaction. Expected Outcome: A detailed analysis report documenting func CLI’s usability findings, including (but not limited to ): 1. Assessment of CLI command organization, structure, and discoverability for new and experienced users 2. Review of help text quality and completeness across all commands 3. Mapping of common developer workflows with identified pain points 4. Evaluation of error handling and the user guidance during failures 5. Comparison with industry best practices for CLI design, with recommendations for closing identified gaps

TBA
Proposal

Refactor Command Processing / CQRS Sub-system

intermediate
The Mifos Initiative•2026Varies175h (Medium)

Apache Fineract’s current command processing system relies on a centralized service and untyped JSON payloads, which limits type safety and causes errors to surface only at runtime. In a financial system, such issues can disrupt critical operations and reduce reliability. This project proposes to migrate selected modules to the new CQRS-based fineract-command architecture, which introduces typed commands, structured handler dispatch, and extensible processing hooks. The migration will cover the full request lifecycle—from REST APIs to business logic—while strictly preserving backward compatibility through unchanged integration tests. Key deliverables include migrating open and unassigned modules to the new architecture, introducing type-safe DTOs with validation, replacing legacy JAX-RS endpoints with Spring Web MVC controllers, integrating the CommandPipeline with typed handlers, removing obsolete legacy components, and producing a comprehensive migration guide to enable future contributions.

mysqljavascriptandroid+5
Student: Aditi Nikam
Code
Proposal

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

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

Create a Kiwix Hotspot application.

intermediate
Kiwix•2019Varies175h (Medium)

<p>Create a Kiwix hotspot application that would be an extension to the kiwix android application. It would allow the users to share their ZIM Files with others over the same network. This can be made possible by:</p> <ul> <li>Creating a layout for the user to select the files he wishes to host.</li> <li>Working with a web server i.e. kiwix-serve. We can communicate with it via JNI(Java Native Interface).</li> <li>Working with WIFI hotspot(without using data).</li> <li>Presenting the IP address where the files have been hosted.</li> <li>Some networking tricks to polish the application.</li> </ul> <p>Other devices can access the ZIM files by just connecting to the hotspot and simply entering the ip address into their browser.</p> <p>This project would be really beneficial in areas especially where internet is not so easily available/accessible. For example, a teacher who has the kiwix android application would be able to share the ZIM files with all the students offline.</p>

pythonandroidjava+11
Student: Adeel Zafar
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

Extending testing and optimising Boost.Multiprecision to higher precision

beginner
Boost C++•2020Varies90h (Small)

<p>Boost is one of the most fundamental collections of C++ libraries, powering thousands of projects, but also driving the development of C++ best practices and C++ standards. Boost.Multprecision is the Boost library providing number types with precision higher than that of C++ built-in types. The library offers support for integer, floating-point and rational data types at compile-time fixed, arbitrary and variable precision.</p> <p>Currently, many operations are already supported for arbitrary precision, but tests exist only for up to 1024 bits. The purpose of this project is to 1) extend testing for precision of thousands of bits and 2) add arbitrary-precision support for more complicated functions and constants. This includes adding tests for arithmetic operations of higher precision, extending tests for simple functions, extending special functions to higher precision, adding support for higher precision constants (and adaptive precision algorithms) and optimising several of the operations (see Milestones for details).</p>

c++ libraries c++11 c++14 c++17 c++20c++c++11+1
Student: Dimitrios Los
Code

LibreCAD 3 OpenGL Rendering

advanced
BRL-CAD•2019Varies350h (Large)

<p>LibreCAD is a free Open Source CAD application for Windows, Apple and Linux. It allows industrial designers and graphics enthusiast to create CAD projects of the highest standard and precision. With this precision and standard comes the need of high quality and accelerated rendering to visualise a document. LibreCAD 3 was designed to have multiple rendering engines without major modifications to its core. Right now LibreCAD 3 uses Cairo for rendering. For users with high resolution screens, Cairo is not convenient because of a slowness, due to a bad integration with Qt and a missing caching system. At each frame when rendering is done the data is sent from CPU to GPU which is very inefficient. OpenGL has lower CPU overhead for draw calls and state changes and lets you take advantage of the GPU to render graphics on your device's screen and performance is excellent. The project consists of replacing Cairo with OpenGL in LibreCAD 3.To make a complete well abstracted OpenGL implementation with C++ for the rendering in LibreCAD.</p>

pythonc/c++opengl+6
Student: Kartik Kumar
Code
Proposal

Solutions architecture for cloud-native deployments (2025 Term 3)

Intermediate
•Varies175h (Medium)

Learning paths with hands-on labs are a crucial resource for DevOps engineers and cloud-native practitioners. The Meshery Playground provides a live cluster environment, making it an ideal platform for learning every kind of cloud and cloud native technology. Meshery Docs is in need of comprehensive tutorials and scenarios covering common infrastructure management use cases. Mission is to create and publish a series of hands-on tutorials using Meshery Playground. Each tutorial will include step-by-step guides, live demonstrations, and interactive labs using the Playground allowing learners to apply their knowledge directly without the hassle of any configuration.These tutorials will be reviewed by various project maintainers and then published in guides/tutorials. Expected Outcome: - 10+ new solution architectures (designs) published in Meshery Catalog - Each design is ideally adjoined with an interactive tutorial (using Meshery Playground), guiding users through infrastructure. - Tutorials should vary in complexity, catering to beginners and advanced learners.

TBA
Proposal

AI-Assisted PostgreSQL Optimization Using EXPLAIN Plans

beginner
CERN-HSF•2026Varies90h (Small)

Nopayloaddb is used to serve time-sensitive conditions data for high-energy physics (HEP) experiments, so performance is critical: slow IOV lookups can delay entire reconstruction workflows. Right now, the database layer doesn’t have replicas or strong observability, even though the application already includes configuration hooks for PgBouncer and read-only database connections. In this 24-week project, I plan to improve reliability and performance by adding streaming replication, along with monitoring using Prometheus, Grafana, and Loki. I’ll also build a replica-based EXPLAIN analysis system powered by pg_stat_statements to safely study query performance. On top of that, I’ll develop a layered AI assistant (combining rules, LLMs, and parameter hints) that provides reviewed, allow-listed optimization suggestions through a simple REST API. All of this will be done without modifying existing Django schemas, and the results will be validated through benchmarking and clear documentation.

pythonc/c++machine learning+6
Student: Sarthak18
Code

3D edition of masks

intermediate
Invesalius•2025Varies175h (Medium)

InVesalius is an open-source software that enables synchronous 2D and 3D visualization of medical images, facilitating the reconstruction of computed tomography (CT) and magnetic resonance imaging (MRI) data into three-dimensional models. It allows users to create masks easily through various preset parameters, such as predefined threshold values for different tissues and materials. However, in cases where automatic segmentation is insufficient, manual editing becomes necessary. This process can be quite slow and labor-intensive, as it requires editing each slice individually, which is particularly time-consuming for large volumes. Implementing a feature that enables mask creation through projections directly on the 3D rendering screen would significantly enhance InVesalius's usability and efficiency. Currently, mask editing in InVesalius requires a slice-by-slice approach, which can be repetitive and prone to errors. By allowing users to edit the entire volume simultaneously via 3D projections, the segmentation process would be streamlined, saving time and increasing accuracy.

pythoncythonnumpy+2
Student: Felipe Cybis Pereira
Code
Proposal

Developing Guidelines for OTel Survey Analysis and Communication (2025 Term 3)

Intermediate
•Varies175h (Medium)

Various special interest groups (a.k.a. SIGs) in the OpenTelemetry project run surveys to understand the experience of the end-users better. To run surveys efficiently, SIG End-user provides guidelines and assistance to people running surveys. In the past, SIG End-user focused on providing guidelines around survey design. Now we would like to move forward and cover survey data analysis and communication findings. Expected Outcome: The mentee in this project will describe a step-by-step survey data analysis process and tools that OTel contributors without deep data analytics knowledge can leverage to analyze their survey data – from cleaning and coding of data, through descriptive statistics, cross-tabulation, to visualization. In addition, the mentee will come up with suggestions on how to improve existing and/or propose new ways to communicate survey findings from surveys to the OpenTelemetry community. [Bonus] The mentee might also execute one survey to test out the guidelines.

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

Solutions architecture for cloud-native deployments (2025 Term 2)

Intermediate
•Varies175h (Medium)

Learning paths with hands-on labs are a crucial resource for DevOps engineers and cloud-native practitioners. The Meshery Playground provides a live cluster environment, making it an ideal platform for learning every kind of cloud and cloud native technology. Meshery Docs is in need of comprehensive tutorials and scenarios covering common infrastructure management use cases. Mission is to create and publish a series of hands-on tutorials using Meshery Playground. Each tutorial will include step-by-step guides, live demonstrations, and interactive labs using the Playground allowing learners to apply their knowledge directly without the hassle of any configuration.These tutorials will be reviewed by various project maintainers and then published in guides/tutorials. Expected Outcome: - 10+ new solution architectures (designs) published in Meshery Catalog - Each design is ideally adjoined with an interactive tutorial (using Meshery Playground), guiding users through infrastructure. - Tutorials should vary in complexity, catering to beginners and advanced learners.

TBA
Proposal

AXIOM Remote: Firmware Improvement And Extension

advanced
Apertus Association•2021Varies350h (Large)

<p>Firmware as the name suggests is a bridge between User and hardware/features of Axiom Remote. Hence, there is a need for Firmware to follow good UI/UX principles,at the same time should not be heavy on the CPU.</p> <p>AXIOM-Remote General UI guidelines clearly mentions how things flow in AXIOM-Remote firmware, and the correct structure and plan one should keep in mind. I tend to follow the structure and at the point of dilemma or turmoil would discuss with mentors.</p> <h4>Task mentioned in Firmware Improvement and Extension</h4> <ul> <li>Event handling (button interactions, turning the rotary knob, etc.)</li> <li>Page setup </li> <li>Add new UI classes</li> <li>Text input GUI</li> <li>Histogram, scopes and other graphs drawing</li> <li>Optimize drawing</li> <li>Add transition animations</li> <li>Unit tests to verify proper implementation</li> </ul>

clinuxfpga+7
Student: Aman Singh (eppisai)
Code
Proposal

Performance Model of an Example RISC-V Out-of-Order Superscalar Processor for Community-wide Use Mentorship Project

Intermediate
•Varies175h (Medium)

RISC-V Performance Modeling SIG is driving the development of Performance Modeling and Simulation Tools for use across RISCV membership, to reduce duplication of effort and to foster collaboration. As such, we have developed a barebones performance model of an example RISCV superscalar processor using C++ based on Sparta simulation framework. We have also identified a clear set of features that need to be added to this model to make it more complete. In particular, we would like to add a branch predictor, register renaming and a memory subsystem hierarchy to the model. The identified set of features are listed here as issues in the repository: https://github.com/riscv-software-src/riscv-perf-model/issues We invite mentees who are passionate about computer architecture and performance modeling to join us in this effort. This is an excellent opportunity to develop a key piece of software that will have high visibility and utility across the entire RISCV community, both in industry and academia. This also presents an opportunity to work with veteran engineers from industry involved in this project.

TBA
Proposal

Python code auto-completion

intermediate
LibreOffice•2025Varies175h (Medium)

LibreOffice has Python scripting support via its UNO API but does not have adequate IDE support because it doesn't have static type information. This project suggests developing a new tool named pythonmaker using C++ in LibreOffice's codemaker framework to create Python stub files (.pyi) based on UNO's IDL definitions. Such stubs will contain correct type hints according to PEP 484/561 guidelines so that features such as autocompletion, static analysis, and improved navigation can be provided in Python IDEs. pythonmaker will make use of existing infrastructure such as codemaker::TypeManager and convert UNO interfaces, structs, enums, and constants into their Python counterparts. The output files will be structured by UNO namespaces, e.g., com/sun/star/. The project also features comprehensive testing using CppUnit, MyPy, Pyright, and actual IDE validation—to provide quality and usability. Overall, this will dramatically enhance the Python development experience within LibreOffice.

pythonandroidjava+2
Student: Manish Bera
Code
Proposal

PersonalAIs: Generative AI Agent for Personalized Music Recommendations

intermediate
Open Technologies Alliance - GFOSS•2025Varies175h (Medium)

PersonalAIs: Generative AI Agent for Personalized Music Recommendations This project aims to enhance music streaming experiences by building an AI agent that offers emotionally intelligent, personalized music recommendations. Traditional recommendation systems often overlook users’ real-time emotional states. To address this, we propose a full-stack solution that uses large language models (LLMs), emotion detection, and Spotify API integration to tailor music suggestions based on users’ mood and preferences. Key deliverables include: • A conversational chatbot UI for user interaction • Emotion detection using LLMs • Integration with Spotify for real-time user data • A hybrid recommendation system (recall & rank) based on listening behavior and emotional context • A frontend-backend architecture for seamless user experience This project will deliver a working prototype capable of understanding user emotions and musical tastes, and recommending tracks that resonate with the user’s current mood.

pythonmysqljava+7
Student: Ke Ye
Code

An Improved Graph Theory IDE

beginner
KDE Community•2019Varies90h (Small)

<p>As a student, I use graphs in almost everything related to my master’s research. Graph Theory is a great mathematical tool for programmers and mathematicians, as it facilitates some computational problems resolution and modelling. However, is not always easy to understand the underlying theory and algorithms.</p> <p>Rocs (<a href="https://kde.org/applications/education/rocs" target="_blank">https://kde.org/applications/education/rocs</a>) is a Graph Theory IDE created in January of 2010, with new updates still being committed almost every month, currently in the KDE repositories, designed for lecturers, students and researchers. It is composed of a visual data structure and a powerful scripting engine in Javascript. Though useful for creating simple graphs, it is still lacking the tools to simplify the creation of bigger graphs, and also of basic graph theory algorithms for beginners. Another improvement it should have is a step by step execution system, in order to fully comprehend the algorithms and facilitate debugging.</p>

c/c++qtqml+6
Student: Caio Tonetti
Code
Proposal

PyLops: MPI backend for distributed inverse problems

advanced
NumFOCUS•2023Varies350h (Large)

Pylops has been developed to solve large-scale inverse problems. Keeping in mind the memory size of a single machine, there is a need to perform the operations in a distributed fashion. The main goal of this project is to use the mpi4py package to exchange messages between different processes across distributed memory. The main outcomes of this project are to develop a DistributedArray class using mpi4py to broadcast or scatter numpy/cupy arrays and perform basic operations like sum, product, dot-product, element-wise product, etc in a distributed fashion. Additionally, MPI functionality will be added to BlockDiag, VStack, and HStack, and the code for forward, centered, and backward finite difference stencils will be updated using Distributed Arrays. Lastly, at least one of the CG, CGLS, and LSQR solvers will be modified to use Distributed Arrays. This will benefit the Pylops Codebase as integrating mpi4py into the codebase will enhance the operators' performance and prevent exceeding memory on a single machine.

pythonjavascriptr+3
Student: Rohan Babbar
Code
Proposal

Automate template version upgrade

intermediate
Qubes OS•2026Varies175h (Medium)

Qubes OS uses TemplateVMs as the base for most application qubes. These templates track upstream operating system releases such as Fedora and Debian, which eventually reach end-of-life and must be upgraded. Today, users generally have two options: 1. Install a fresh template and manually recreate customizations and packages. 2. Perform an in-place upgrade manually by following a multi-step process across dom0 and the template terminal. The first option is safer but discards customization. The second preserves customization but is cumbersome, error-prone, and inaccessible to many users. This project proposes an automated template version upgrade workflow built on top of Qubes OS's existing update architecture. The primary deliverable is a dom0 command-line tool that performs distro version upgrades for Fedora- and Debian-based templates while preserving safeguards, reporting progress, and leaving a clear recovery path on failure. GUI integration is a stretch goal after the CLI workflow is stable and tested.

cpythonxen+3
Student: nihalxkumar
Code
Proposal
Showing 3529 - 3552 of 3883 Projects
146147148149150
Proposal
Proposal
Proposal
Proposal
Proposal