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

Add virtio-net Control Virtqueue state restore support

intermediate
QEMU•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 →
175h (Medium)

Virtio-net device uses Control Virtqueue(CVQ) for changing device parameters. For some devices, such as vDPA, its CVQ is passed from Guest’s driver directly to Host driver, which makes it difficult for QEMU to track the status of these devices. To solve this problem, QEMU introduces Shadow Virtqueue(SVQ) for vdpa device, which shadows the CVQ via QEMU instead of being assigned directly to Guest. During QEMU Live migration, to restore the vdpa device in the destination VM to the state in the source VM, SVQ can use CVQ’s interface and send the state as regular CVQ commands. Due to some CVQ commands for vDPA are missing at present, this project aims to achieve support for a subset of CVQ commands, including VIRTIO_NET_CTRL_RX family commands, VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET command, VIRTIO_NET_CTRL_VLAN_ADD command, VIRTIO_NET_CTRL_MQ_HASH_CONFIG command and VIRTIO_NET_CTRL_MQ_RSS_CONFIG command for vDPA.

cassemblykvm+4
Student: Hawkins Jiawei
Code
Proposal

Social Street Smart

intermediate
AOSSIE•2023Varies175h (Medium)

The objective of the project is to develop a Chrome extension with the purpose of identifying fraudulent information, thereby enhancing online safety and fostering greater productivity for internet users. The project entails a series of stages, primarily focused on the utilization of Natural Language Processing methodologies. During this season, a context detection functionality will be integrated, leveraging the capabilities of the GPT-3 API to provide users with comprehensive insights into news articles, empowering them to make well-informed decisions. The final output will be the updated web service and extension, which will be ready for publishing. The project also aims to enhance the SSL validator and Security Header to ensure maximum security. To achieve this, the codebase will be migrated from Manifest Version 2 to Manifest Version 3, and the model must be integrated into the Chrome extension. The final product will provide users with a reliable tool to identify fake news and ensure that they receive accurate information while browsing the internet.

pythonjavascriptswift+8
Student: Harish Dendukuri
Code
Proposal

Implement a proper testing framework (rpmlint)

beginner
openSUSE Project•2023Varies90h (Small)

The primary objective of this project is to enhance the testing framework and testing ideology by utilizing mocking techniques. The intention is to get rid of the existing binary rpm packages . This project aims to mock all the 132 binary rpm packages used exclusively for testing purposes in the rpmlint repository, which will significantly improve testing speed and facilitate easy testing development. To achieve the project's goals, I will collaborate with my mentor and devise a strategy for mocking the binary packages using the pytest framework. The deliverables for this project include a redesigned testing framework that is more efficient and reliable than the existing one. Additionally, the project aims to mock all the existing binary packages, which will help streamline testing processes and accelerate software development. Deliverables: 1. Coming up with redesigned testing framework using mocking strategy. 2. Mocking all the existing binary packages

pythonlinuxjavascript+11
Student: Afrid Hussain
Code

Bowtie and the World of JSON Schema

intermediate
Postman•2023Varies175h (Medium)

The world of JSON Schema is immense. JSON Schema tooling exists in countless languages across a variety of uses (data validation of course a noteworthy and prominent one). Implementing the JSON Schema specification(s) in a fully compliant way is not without challenge, meaning as a user of JSON Schema it is important to understand how a particular implementation may deviate such that one can make constructive tooling choices or help implementations improve. Bowtie is a recently created tool to aide in this task, helping to surface the conformance of various JSON Schema tools with the specification by running them against a set of known correct test cases and regularly rendering the results to a web page. But it can do more! Expected Outcomes: Enhance (or replace) Bowtie's simplistic current UI so that it most easily answers "what do various implementations say about each test case" -- making it snappier and more featureful Add support for further JSON Schema implementations by creating Bowtie harnesses in additional languages Teach Bowtie to compare not only True/False validation results but also the full JSON Schema standardized output formats

javascriptnode.jsgraphql+5
Student: Agnivesh Chaubey
Code
Proposal

Document the contributor journey to GitLab

intermediate
GitLab•2023Varies175h (Medium)

This project aims to simplify the contribution process to GitLab by creating a detailed report for developers using both local and cloud-based Integrated Development Environments (IDEs). The report will identify areas where the process can be improved, and the mentee will work to address 20% of the identified gaps. The ultimate goal is to enhance the contribution experience and make it more inclusive to a broader community of developers. The project can be broken down into 3 parts Research and analysis: Aims at conducting a user research to understand the contributors journey to Gitlab. A user can contribute to gitlab in many ways through Development, Documentation, UI/UX , translation etc. main work would be to identify the contributors journey in each of those. Addressing gaps in the contributor journey Creating a list of identified gaps and discussing a way to tackle those gaps. Improving the Onboarding process Contributing to Gilab can be overwhelming, this aims at identifying the hurdles that a new contributor faces and come up with an idea to improve the process.

rubygolanggit+6
Student: Niku Singh
Code
Proposal

Mifos Mobile 6.0 - Mobile Banking App - GSoC proposal for The Mifos Initiative

intermediate
The Mifos Initiative•2023$3k–$6.6k175h (Medium)

Mifos Mobile is an android application designed for client use, which facilitates user authentication, account information viewing and editing, as well as internal transactions and repayments. In my proposal I've mentioned 4 additions to the current Mifos Mobile application. 1. Replacing the current API layer from self-service Fineract APIs to Open Banking APIs 2. Providing the user 24/7 customer chat support using RocketChat 3. Integrating external payment system, Mojaloop via the Payment Hub. 4. Covering all the screens with UI tests using Espresso. The proposed enhancements to Mifos Mobile application are expected to have a significant positive impact on the user experience. By replacing the existing API layer with Open Banking APIs, clients will be able to enjoy seamless and more secure transactions. The provision of round-the-clock customer chat support through RocketChat will ensure that users receive prompt assistance whenever they require it. Integration of Mojaloop through the Payment Hub will enhance the application's payment capabilities, and it's reach. Lastly, the coverage of all screens with UI tests using Espresso will improve the overall reliability and robustness of the application, leading to increased user satisfaction.

mysqljavascriptandroid+5
Student: Abhishek Gururani
Code

Dubbo GSoC 2023 - Development of Dubbo Admin Dashboard UI Pages

advanced
Apache Software Foundation•2023$6k–$13.2k350h (Large)

Summary of the Development of Dubbo Admin Dashboard UI Pages: Firstly, I analyzed the specifications of the previous code in order to facilitate subsequent development and maintenance.Secondly, I optimized the functional modules that had already been implemented, and further upgraded some functions to make them more user-friendly.Finally, and most importantly, I analyzed the requirements for the new function, read through interface documents, implemented the interface, performed data joint debugging, and ultimately completed all functions and tested their functionality.

pythonjavascriptjava+7
Student: yongshuai wang
Code
Proposal

Re-optimization using JITLink

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some functions (which we call hot functions) are used very frequently and for these functions it is worth optimizing more heavily. In general hot functions can only be identified at runtime (different inputs will cause different functions to become hot), so the aim of the reoptimization project is to build infrastructure to (1) detect hot functions at runtime and (2) compile them a second time at a higher optimization level, hence the name "re-optimization". There are many possible approaches to both parts of this problem. E.g. hot functions could be identified by sampling, or using existing profiling infrastructure, or by implementing custom instrumentation. Reoptimization could be applied to whole functions, or outlining could be used to enable optimization of portions of functions. Re-entry into the JIT infrastructure from JIT’d code might be implemented on top of existing lazy compilation, or via a custom path. Whatever design is adopted, the goal is that the infrastructure should be generic so that it can be used by other LLVM API clients, and should support out-of-process JIT-compilation (so some of the solution will be implemented in the ORC runtime).

cllvmc+++3
Student: Sunho Kim
Code
Proposal

Reducing Fossology's false positive copyrights

intermediate
FOSSology•2023Varies175h (Medium)

This project’s goal is to improve the accuracy of Fossology’s copyright detection system using machine learning. This functionality was originally implemented in 2021 to improve the two-step process of copyright detection used by most copyright detection software; using Regex and then human intervention. The machine learning approach uses Named Entity Recognition (NER) and Part of Speech (POS) tagging to figure out which statements contain copyright and which do not. I’ll be working on improving all parts of the project; starting from the dataset & preprocessing, then working my way to the NER hypothesis until the machine learning model used and the final integration.

linuxpostgresqlc/c+++7
Student: Abdelrahman Jamal
Code
Proposal

Fineract Modularization

advanced
The Mifos Initiative•2023Varies350h (Large)

This project aims to modularize Fineract, an open-source financial services platform, by creating independent Java libraries that can be used be used by developers. Fineract manages clients, transactions, accounts, and other financial activities for financial service providers. It is designed to be robust, reliable, and customizable, allowing for integration with third-party systems. As the software has evolved over time, it has become increasingly complex and monolithic—leading to the need for this project.

mysqljavascriptandroid+5
Student: Abhinav Sinha
Code
Proposal

Hash Maps That Don’t Hate You: A Proposal For Fast, Insertion-Ordered Hash Maps in Truffleruby

advanced
Ruby•2023Varies350h (Large)

The project this document proposes is that of implementing the hash map structure described in high level detail in the article Hash Maps That Don’t Hate You (https://blog.toit.io/hash-maps-that-dont-hate-you-1a96150b492a), an elegant variation over standard open addressing hash tables that, instead of storing the Key-Value pairs themselves in the array backing the hash table, it stores indices into yet another insertion-ordered backing array. This allows us to have our cake and eat it too : we get insertion-order iteration while still maintaining most of the desirable performance guarantees expected from hash tables, with reasonable implementation complexity. Deliverables: A build of truffleruby with a Hash implementation as described in the article, supporting all standard Ruby Hashes operations (as of Ruby 3.1) and hopefully faster and\or more memory efficient than the current implementation of Hashes in truffleruby.

rubycjava+3
Student: Mostafa-M-K
Code

Mifos Mobile 6.0 - Mobile Banking App

advanced
The Mifos Initiative•2023Varies350h (Large)

Mifos Mobile is an android application built on top of the MifosX Self-Service platform for end-user customers to view/transact on the accounts and loans they hold. Data visible to customers will be a sub-set of what staff can see. The project aims to update and improve the technology stack of a self-service Fineract API system by migrating to Open Banking APIs, implementing Hilt for dependency injection, and adopting MVVM-Clean architecture with Navigation Graph and Coroutines. The project also requires integration with an external payment system such as Mojaloop or mPesa and unit and UI testing. The deliverables include an updated and efficient project with improved functionality and performance, Github workflows, and continuous integration and delivery.

mysqljavascriptandroid+5
Student: Pratyush Singh
Code
Proposal

TileLink Uncached Heavyweight (TL-UH) implementation in Azadi-SoC

intermediate
Micro Electronics Research Lab - UITU•2023Varies175h (Medium)

In this proposal, I am going to introduce the steps needed to upgrade Tilelink Uncached Lightweight (TL-UL) bus protocol to TL-UH (Tilelink Uncached Heavyweight). The main difference between TL-UL and TL-UH is that 3 additional types of operations are added in TL-UH that cause it to be more efficient. Those operations briefly are the hint operations and atomic operations.

RISCVProcessorHardware+2
Student: Doaa Magdy
Code
Proposal

Expanding Support for GCP Resources with Modularized Crawler

intermediate
GCP Scanner•2023Varies175h (Medium)

GCP Scanner is a crucial tool for security engineers, providing insights into the access levels of various GCloud credentials. This project proposal focuses on enhancing the GCP Scanner by supporting scanning for additional GCP resources such as Cloud Run, Cloud DNS, Datastore, etc. Additionally, a plan for refactoring the crawler and unit tests for better maintainability and scalability is proposed. It also includes my relevant experience, contributions, and qualifications to maintain and improve the GCP Scanner.

pythongoogle cloud
Student: Sudipto Baral
Code
Proposal

Boosting canonicalization performance by replacing N-dimensional sparse tensor representation

advanced
NumFOCUS•2023Varies350h (Large)

(This project is for CVXPY) The performance of canonicalization procedures for optimization problems is an important metric for CVXPY users. Typically, this process is quite slow for large Disciplined Parametrized Programs(DPP). However, it is possible to improve upon the canonicalization by replacing the way 3D sparse tensors are represented. One of the major updates of CVXPY 1.3 was the addition of a SciPy backend, which allowed a performance speedup for certain types of optimization problems. This new backend offers an alternative to the original C++ backend implementation (CVXCORE), and enables easier development. The SciPy backend has some limitations especially when it comes to manipulating sparse tensors with 3 dimensions. The current representation of a 3D sparse tensor is to use a list of 2D matrices. However, a sparse tensor of large dimension could be represented as a single strided matrix, which can make CVXPY backend operations orders of magnitude more efficient.

pythonjavascriptr+3
Student: WilliamZijieZhang
Code

GPU Support for QuantumClifford.jl

intermediate
The Julia Language•2023Varies175h (Medium)

QuantumClifford.jl is a package designed for simulating Quantum Clifford circuits, circuits that consist of Clifford gates. QuantumClifford.jl can be highly useful for designing Quantum error-correcting codes. Since applying Clifford gates to Stabilizer states is mathematically similar to Linear Algebraic operations, we can utilize GPU to parallelize the process and make it significantly faster. This Summer of Code project consists of implementing the aforementioned Clifford gate operations in GPU kernels, and then seamlessly integrating them into the rest of the QuantumClifford library.

cjavascriptc+++12
Student: Shayan Pardis
Code
Proposal

pg_statviz: Time Series Analysis & Visualization of Statistics

intermediate
PostgreSQL•2023Varies175h (Medium)

pg_statviz is a PostgreSQL extension with a command line utility pair. The extension can snapshot cumulative and dynamic statistics of various PostgreSQL internal tables. These snapshots are stored in another schema, pgstatviz, which can be queried using SQL for analysis. The python command-line utility accesses the tables in this schema to perform time-series analysis and create visualizations. Using the packages, database administrators can efficiently perform sophisticated analysis of their PostgreSQL database statistics over different time intervals. The project includes the following deliverables: - increased number of modules to the extension. - addition of regression tests to the extension - implementation of a long term retention policy. - packaging of the tool for various Linux Distribution. - Add Documentation about the tool.

cpostgresqlperl+8
Student: Rajiv Harlalka
Code

Migrate mv2 samples to mv3 and increase API coverage

advanced
Chromium•2023Varies350h (Large)

Manifest V3 is the latest version of Chrome extensions, which focuses on security, privacy, and performance. The goal of this project is to upgrade Chrome extension samples to work with Manifest V3 and increase API coverage, which includes providing minimal API samples and providing samples that use multiple APIs with practical purposes. You could refer to the proposal for specific schedule.

pythonjavascriptjava+2
Student: Xuezhou Dai
Code
Proposal

Out-of-process RDP server for QEMU

intermediate
QEMU•2023Varies175h (Medium)

QEMU is able to export its display over D-Bus. We can create a server that uses the provided API to export the display over the network. There is already an experimental VNC server, but RDP is more popular and would provide more features and better efficiency.

cassemblykvm+4
Student: Mihnea Buzatu
Code
Proposal

Image Lab

intermediate
SCoRe Lab•2023Varies175h (Medium)

The proposed project aims to revamp the entire front-end of the app. The new front-end will be built using React on top of Electron to match industry standards. The project will also include adding a test suite and updating the documentation. The proposed changes will make ImageLab a more comprehensive and user-friendly tool for anyone looking to get started with image and video processing.

pythonmachine learningweb development+8
Student: Abdullah Ranginwala
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

Accessibility Improvement for Uyuni

intermediate
openSUSE Project•2023Varies175h (Medium)

The goal of this project is to analyze, track, document and solve accessibility issues in Uyuni, thereby increasing the accessibility support of Uyuni. This solution involves implementing keyboard navigation and assistive technology support, enhancing the visual interface to make it more inclusive, and conducting thorough testing to ensure the tool is accessible to all users, regardless of their abilities.

pythonlinuxjavascript+11
Student: Odetayo Rachael
Code
Proposal

Data Privacy Policy Definition and Function Verification for Teaclave

advanced
Apache Software Foundation•2023Varies350h (Large)

Teaclave currently lacks a mechanism for data providers to enforce policies on the data they upload, and also it cannot verify that the behavior of the uploaded function conforms to the expected rules. These two gaps leave the system vulnerable to exploitation by malicious actors. To solve the problem, verification should be exerted on the uploaded function so that its behavior that it strictly conforms to a prescribed policy. The standard formal verifier can be adopted (e.g., Prusti, Creusot) to formally verify the function's behavior. A set of deliverables as follows can be anticipated in the coming future. Milestones: Basic policies (e.g., addition, subtraction) of the data can be verified by Teaclave; Complex policies can be verified. Components: Verifier for the function code; Policy language adapters (adapt policy language to verifier); Policy language parser; Function source code converter (append policies to the functions). Documentation: The internal working mechanism of the verification; How to write policies for the data.

pythonjavascriptjava+7
Student: Hiroki Chen
Code

Add WebAuthn 2 support for Plone

intermediate
Plone Foundation•2023Varies175h (Medium)

The project proposal is to bring password-less authentication to Plone 6 by implementing WebAuthn, a password-less web standard by W3C. The proposal suggests that the implementation should allow the user to decide whether to use WebAuthn as the primary or second-factor authenticator. WebAuthn uses public key cryptography to store user credentials, which makes it more secure than traditional password-based authentication methods. However, the proposal also discusses the challenges of using WebAuthn, such as the Scenario where the authenticator device is not available or lost. The proposed solutions include backup codes, recovery codes, and administrator reset, but all of them require storing some kind of secret on the server, which is a security concern. The proposal suggests alternative solutions like encouraging users to use at least two different Authenticating devices to register.

pythonjavascriptrest+4
Student: Pavan-Thota
Code
Proposal
Showing 3841 - 3864 of 11996 Projects
159160161162163
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal