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

Enable & Improve Multi Display Chrome Testing Capabilities

intermediate
Chromium•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)

In this project, our aim is to enable the capability for testing multi-display APIs for Chromium, on Windows OS. In order to achieve this, we are manipulating and developing an Indirect Display Driver (IDD) for enabling virtual display(s) for mocking the APIs. The main reason for doing this is because the users on Windows OS face various issues while using multi-display features of Chromium, and this leads to a bad user experience. For this reason it is important to have extensive, automated testing capabilities so that APIs may be improved drastically.

pythonjavascriptjava+2
Student: Avi Mathur
Code
Proposal

Prototyping Support for Content Addressable Systems like IPFS in TUF

intermediate
CNCF•2023Varies175h (Medium)

The TUF specification provides explicit guidelines for how artifacts should be hashed and later verified to guarantee their integrity. However, Content Addressable Systems like Git, IPFS (InterPlanetary File System) and OSTree have their own mechanisms for ensuring the integrity of artifacts. When TUF is used with these systems, it is redundant for it to also ensure artifact integrity. This project provides solution to this issue by delegating the responsibility of artifact integrity verification to the underlying content addressable systems themselves, while still using TUF to manage the metadata and provide additional security measures.

gorustkubernetes+3
Student: Shubham Nazare
Code
Proposal

DSP hard block integration in F4PGA

intermediate
CHIPS Alliance•2023Varies175h (Medium)

F4PGA is an open-source FPGA toolchain designed as a free alternative to proprietary computer-aided design tools like Xilinx’s Vivado. Currently, mapping designs to DSP blocks and generating DSP block bitstreams are not implemented for the Xilinx 7-series FPGA devices within the toolchain. This project aims to integrate DSP48E hard block in F4PGA. This will enable designs using DSPs to be synthesized, placed, and routed correctly. We need to diagnose and implement required changes throughout the F4PGA toolchain, allowing for DSP design bitstreams to be successfully generated with open-source tools. Deliverables: 1. Support for DSP48E within the F4PGA architecture definitions. 2. Testing flow for designs using Xilinx 7-series DSP hard blocks which include Verilog-to-Bitstream using the F4PGA toolchain, Fasm2bels to re-generate the original netlist from the bitstream output of F4PGA and Proof-test through Vivado to verify the correctness of the netlist.

fpgachiselrisc-v+2
Student: Abhishek_Anand
Code
Proposal

Implementing RateLimit Plugin for Coraza WAF

advanced
OWASP Foundation•2023Varies350h (Large)

Rate limiting is a technique used by computer systems to control the rate of traffic sent or received by a particular entity (such as an application or a user). The goal of rate limiting is to prevent a single entity from overwhelming the system with too many requests at once causing resource exhaustion, security vulnerabilities, API abuse, and unpredictable behavior. The objective is to develop a plugin for Coraza WAF which prevents ‘rate-based attacks’ and provides more security and stability to the applications behind the wall. In brief, this is to be accomplished by creating a new directive `SecRateLimitOptions` for specifying the rate limit options(no. of requests allowed per minute, the algorithm used, when to clear rate limit, default action if rate limit exceeds) and a new non-disruptive action `rate limit` which enforces rate-limit on the matching chains of SecRule. A more detailed explanation can be found in the proposal PDF. The set of deliverables, in the end, would be the plugin itself, support for distributed systems, and well-written documentation with examples, benchmarks, and recommended settings.

pythonjavascriptjava+10
Student: Shivansh Verma
Code
Proposal

Continuous Integration: Test Programs for libcupsfilters, libpappl-retrofit, libppd, CPDB, CPDB Libs

intermediate
The Linux Foundation•2023Varies175h (Medium)

To protect a free software project worked on by several contributors against regressions caused by a committed change, one needs frequent, automated testing of the code base, ideally triggered by every commit into the repository. This is called Continuous Integration (CI). What is triggered on each commit is usually some static analysis of the code using common, specialized tools and build and execution tests, usually doing `./configure; make; make test` on different system platforms. This naturally requires test scripts/programs compiled and run by the `make test` step. For CUPS, for example, the daemon is started (on an unprivileged port so that it does not need root), queues created and listed, jobs sent, and the logs checked whether everything went OK. For Ghostscript, a large collection of input files (gathered from bug reports) is processed and converted into raster formats. The task here is to write test programs for the different OpenPrinting projects so that `make test` does something useful, efficiently catching regressions. They should exercise important functionality of the software with different parameters and analyze logs and output files to check whether the program did the expected work. Test programs are also needed for the so-called 'autopkgtest' tests which are added to Debian packages and executed whenever the package is uploaded to Debian or Ubuntu. In addition, instruction files and shell scripts are needed to build the software on different platforms/environments, run tests, and create GitHub Actions (for the automatic triggering on each commit)

cpythonmysql+7
Student: Pratyush Ranjan
Code

Facilitating H5P and SCORM import in Kolibri Studio

intermediate
Learning Equality•2023Varies175h (Medium)

This project tries to solve the problem of importing two new file formats called H5P and IMS Content Package (SCORM). These packages' metadata needs to be extracted and used to create a course node ( topic node and resource node ) which will later be used to render the files for educational content. To make the content available offline, this project aims to download all the externally linked reference links and embed them along with the file. This will be achieved using various npm packages like JSZip and fast-xml-parser to parse and extract the metadata from the content files and JavaScript to download the externally linked files and embed them into the files for offline use.

pythonjavascriptdjango+1
Student: Manav Aggarwal
Code
Proposal

Enhance chrome://policy page

intermediate
Chromium•2023Varies175h (Medium)

The "chrome://policy" page is a URL in the Google Chrome browser that displays a list of policies applied to the browser. These policies determine the settings and behaviour of the browser. The aim of the project is to enhance the functionality and user experience of the "chrome://policy" page, to create a user-friendly and visually appealing interface that provides administrators with the information they need to effectively manage the policies. The new design will prioritize readability, information transparency, ease of use, and a responsive design across desktop and mobile platforms. There is also additional scope to introduce additional fields to the page to improve its usability.

pythonjavascriptjava+2
Student: Aryan Kaushik
Code
Proposal

Epoptes improvements

intermediate
Open Technologies Alliance - GFOSS•2023$3k–$6.6k175h (Medium)

Introduction Epoptes (Επόπτης - a Greek word for overseer) is an open source computer lab management and monitoring tool. It allows for screen broadcasting and monitoring, remote command execution, message sending, imposing restrictions like screen locking or sound muting the clients and much more! It can be installed in Ubuntu and Debian based labs, it has been translated in more than 40 languages and it’s currently in use by thousands of schools and businesses around the world. This project aims at making Epoptes even more widely available by creating packages for other Linux distributions, while also addressing several outstanding issues such as firewall friendliness, systemd and Wayland support. Project goals The Epoptes community members have been requesting the following features and improvements for a long time, and I plan to implement them as part of this GSoC project: • Make Epoptes available on more Linux distributions. • Support screen sharing on Wayland. • Drop the session service and keep only the system epoptes-client service. • Use systemd socket activation and autorestart. • Improve its firewall compatibility.

pythonmysqljava+7
Student: Myrto Georgopoulou
Code
Proposal

Create a gprMax custom kernel and that can be installed in Jupyter notebook

intermediate
gprMax•2023Varies175h (Medium)

gprMax is CLI interface software which is used to solve electrodynamics problems by solving Maxwell's Equations using FDTD method. It is also used to simulate Ground Penetrating Radar for various industry and academia purpose. But it's installation can become a bit cumbersome and nowadays people prefer a GUI interface. Hence I helped to develop a custom gprMax kernel which can be used to build and run models in Jupyter Notebooks. I also developed a python function that can be used to visualize the 3D geometry of the models in notebook environment.

pythoncythoncuda+3
Student: srutanik
Code
Proposal

YCbCr Support for the Nouveau Vulkan Driver

intermediate
X.Org Foundation•2023Varies175h (Medium)

YCbCr is a color space used in video and digital systems to express color, where Y is the luma component and CB and CR are the blue-difference and red-difference chroma components respectively. This project aims to add YCbCr support to the Nouveau Vulkan driver (NVK), which opens the way for support for more applications and is also an important step towards Vulkan 1.1 compliance. Work on this project is split into 4 phases; first investigation and reading up the relevant parts of the Vulkan specification and the open-sourced NVIDIA hardware headers, second the actual implementation and coding, and finally the third and fourth stages being verification and review where I verify that the implementation is working and conformant, and fix any issues that pop up. All this would then be followed by a merge request implementing and enabling YCbCr support in the driver.

copenglc+++5
Student: Mohamexiety
Code
Proposal

Timeframe for Metrics

advanced
CNCF•2023Varies350h (Large)

Currently, the Metrics Controller in the Keptn Lifecycle Toolkit only allows querying a single value per metric. This project will enable users to define timeframes for metrics and get standardized aggregated results for the given timeframe. The addition of time frames for metrics would provide developers with a lot of flexibility when analyzing their application’s performance as they would be able to easily switch between different timeframes to get a better understanding of how their application is performing. This can be achieved by modifying the structure of the Metric CRD by adding certain fields and then modifying the APIs of our Metric providers to support these newly added fields. The metrics controller would be able to query metrics over a timeframe and then return raw values from the providers which can then be passed to the aggregation functions to calculate the desired aggregated value. These values would be updated in the Metric CRD.

gorustkubernetes+3
Student: Rakshit Gondwal
Code
Proposal

Automatic Differentiation in the Faust Compiler

intermediate
GRAME•2023Varies175h (Medium)

Support for differentiable Faust algorithms is currently provided by an external JAX backend. The aim of this project is to add automatic differentiation capabilities to the Faust compiler with a view to enabling a variety of machine learning approaches to digital audio synthesis and signal processing directly within the Faust language.

cpythonjavascript+3
Student: trusht
Code
Proposal

CRS #3: WAF Performance Testing Framework

advanced
OWASP Foundation•2023Varies350h (Large)

Performance evaluation is one of the concerns about using ModSecurity and Core Rule Sets. More specifically, people take different approaches to examine the performance, such as stability tests (e.g., the peak of I/O, speed of re-connection) and capacity tests (e.g., use of disks). However, individuals often miss measuring before/after using the Firewall. Secondly, although there are many open-source utilities (e.g., Apache JMeter, httperf), no specific tool is designed to evaluate performance affected by a firewall. To address the issue, I suggest creating a CLI tool to benchmark the performance with CRS. A list of deliverables includes: 1) Define a framework for testing performance for a generic WAF. 2) Research existing utilities for performance testing on WAF. 3) Create a CLI tool to achieve the framework and define different types of testing performed by the tool. 4) Implement different types of performance testing. 5) Integrate the CLI tool with pipelines (e.g., GitHub pipeline). 6) Based on the existing Docker images, perform different evaluations with different configurations/versions. 7) Documentation.

pythonjavascriptjava+10
Student: Dexter Chang
Code
Proposal

Hybrid: Build User Portal For Talawa

intermediate
The Palisadoes Foundation•2023Varies175h (Medium)

Currently, Talawa misses a web-app for regular users. Creating a User Portal for regular users, makes Talawa accessible to an even larger audience. User can send direct messages, group messages, view/create/delete posts, create/view/delete events through the User Portal. The user portal will be created using Material UI.

javascriptmongodbnode.js+5
Student: Noble Mittal
Code
Proposal

Exploring Intersection of Civic Technology and Large Language Models

intermediate
Mayor's Office of New Urban Mechanics•2023Varies175h (Medium)

For years, the government has struggled to provide helpful information for residents in need. Sometimes the resources are not readily accessible, or the channel of communication is simply missing. Many people have questions about government policies but don’t know where to ask or never bother to read through official documents; instead, they end up getting incomplete or misleading information from the web. These issues call for a system that handles queries on a large scale with high efficiency and consistency - this is where large language models (LLM) come into the picture. With the help of exciting tools like LlamaIndex, we are now able to extend the knowledge base of LLMs like ChatGPT to more specific domains and tailor the model’s responses to be more relevant to the residents’ needs. This project will extend ChatGPT’s knowledge base with specific government data (such as pdfs of housing policies) and provide a frontend interface for user to interact with a ChatGPT-style chatbot. In addition to the ability to chat and ask questions, users will also be given the power to evaluate responses of the chatbot by giving a thumb up/thumb down to the response.

pythonjavascriptruby+1
Student: August Fu
Code

MEASURING ENERGY CONSUMPTION USING REMOTE LAB

intermediate
KDE Community•2023Varies175h (Medium)

Sustainability is a key goal for KDE over the next two years. As part of this goal, KDE aims to measure the energy consumption of its software and eco-certify applications with the Blue Angel ecolabel. Currently, we measure the energy consumption of our software using a lab based in Berlin following the process documented in the KDE Eco Handbook (Handbook: Applying The Blue Angel Criteria To Free Software). The lab setup requires (i) a test PC (System Under Test) to run user-emulation scripts, (ii) a power meter to measure the energy consumption of the test PC, and (iii) another PC (Data Aggregator & Evaluator) to collect and analyze the output data. In the current setup, developers must rely on individuals in Berlin to test software for them on-site in the lab. This proposal aims to provide remote access to the lab in two steps: first, automating the energy measurement process, including providing a summary of the results; and second, setting up backend CI/CD integration for measuring energy consumption. By automating the process and providing remote access, we make it possible for developers to measure the energy consumption of their software from any location in the world. The increased access to the lab will enable data-driven decision-making for efficiency improvements in code and software eco-certification with agencies like the Blue Angel. The proposed project has three main goals: i) Measurement Automation: Implement a solution where a developer provides as input three scripts (baseline, idle mode, and standard usage scenario) with a config file and automatically obtains a summary of results from OSCAR (Open source Software Consumption Analysis in R). ii) Remote Access 1: Implement a CI/CD pipeline as a backend solution for performing the energy consumption measurements in the remote energy measurement lab.

c/c++qtqml+6
Student: Karanjot
Code
Proposal

Automate testing of stylus touch pen

intermediate
Chromium•2023Varies175h (Medium)

This project aims to automate the testing of stylus touch pens with Chromebook using a human motion robot (HMR). Currently, stylus pens or any other touchpad-related test cases take much longer time and are more expensive when going through lab testing. Developing and conducting these tests via a human motion robot will save half the cost and accelerate the testing time from 13 hours to 15 minutes. The objectives of this project include evaluating and assessing the pass/fail of stylus test cases, developing automation scripts for onboarding the HMR, and implementing the HMR’s testing lifecycle to run and evaluate test results. A three-step evaluation procedure has been proposed, and the onboarding automation scripts and the HMR lifecycle have been implemented. Evaluation results show successful evaluations with directions on future work aiming to improve and scale up the proposed approach.

pythonjavascriptjava+2
Student: Douglas Hou Nam Chiang
Code
Proposal

Improving Relational Assumptions in SymPy’s New Assumptions

advanced
SymPy•2023Varies350h (Large)

The assumption system underlying SymPy is very important to the library's function. However, it has several flaws, including sluggish performance and being overly interconnected with the core of SymPy. As a result of its flaws, a new assumption system, the "new assumptions," was proposed about a decade ago. Since then, the community has made slow but incremental progress in transitioning to and improving this new system. One of the main reasons for this change is that the old assumption system doesn't allow for relation assumptions to be expressed. While the new assumption system does support relational assumptions, the current implementation is very limited. My project aims to address this limitation by enabling the new assumption system to make inferences based on equalities and inequalities, such as "if x > 0, then x must be positive."

pythonc++numpy+1
Student: Tilo Reneau-Cardoso
Code

Administration System - BookBrainz

intermediate
MetaBrainz Foundation Inc•2023Varies175h (Medium)

BookBrainz currently has no administration system, or any good way of giving users special privileges. This project involves devising and implementing a basic admin system allowing for a flexible privilege hierarchy. This project will also include creating relationship and identifier editors which allow privileged users to edit and add relationships and identifiers.

pythonjavascriptperl+8
Student: Shivam Awasthi
Code
Proposal

Multi-camera calibration part 2

intermediate
OpenCV•2023Varies175h (Medium)

This project extends the work from the previous year, which included basic algorithms for multi-camera calibration, by adding testing cases with wider coverage, refining the algorithm to be comparable to the Kalibr tool, and improving the API to make it more accessible to users. Additionally, it plans to create improved documentation to guide users with little background knowledge in camera calibration. The overall goal is to provide a reliable and robust implementation of camera calibration algorithms in a multi-camera setup.

pythonmachine learningc+++9
Student: Linfei
Code
Proposal

Creating Pure-Python Fallback Dependencies

advanced
AboutCode•2023Varies350h (Large)

Currently sctk uses pyahocorasick intbitset for license detection & lxml for creating cyclonedx-xml output formats. All three of them are currently implemented as a extension of python using c or cython these libraries are important for the performance of scancode, but they need to be compiled and installed in a specific way, which may not be possible on all computers. This can make scancode less portable or difficult to use for some users who do not have the necessary tools or libraries installed on their machines. Therefore to address this issue the proposal is to create fallback dependencies, that are written in python and can be used by scancode when the required c libraries are not available making it easier to install and use on a wider range of machines

pythonjavascriptc/c+++6
Student: Jay Kumar
Code
Proposal

Add Acrostic Puzzles to GNOME Crosswords

intermediate
GNOME Foundation•2023Varies175h (Medium)

This project would start by extending a library called libipuz. This library loads and saves puzzles from the free ipuz file format. They would add support to load Acrostics from disk. Testing support will also be added. Once the files are loading, they would add support to the game itself through widget work. They'd have to write two custom widgets. First, they would write an answer widget that contains a sub-grid and links styles with the main grid. Then they'd modify the clue row widget for acrostics to support the different types of clues. As a final step, a separate widget will be written to add a custom layout for acrostics. Given those acrostics behave differently than crosswords, we want to lay them out differently. This can be done either by extending the existing custom widget, or them writing their own.

cpythonjavascript+4
Student: Tanmay Patil
Code
Proposal

Joint Power and Rate Control in User space for Freifunk OpenWrt Mesh & Access Networks

advanced
freifunk•2023Varies350h (Large)

The IEEE 802.11 specification for Wireless Local Area Networking (WLAN) has been widely deployed worldwide due to its low cost and convenience in providing internet access. As such, the performance of WiFi networks is far from optimal, especially when multiple participants share the same channel in an uncoordinated manner. Hence, resource allocation in wireless transmission plays a vital role in optimizing the throughput of a link. The aim of this project is to implement a joint power and rate controller in user space using the Rateman Python package. As a rate control algorithm in user space has already been developed at SupraCoNeX, namely "py_minstrel_ht", this variant of Minstrel-HT can be extended with power tuning capability to better manage interference and increase spatial reuse. In general, the proposed joint controller will consist of a power tuning module that tweaks the power level of the set of best rates, selected by the Minstrel-HT, to an optimal value. Furthermore, the joint controller could also be extended to support modes such as fixed power and low power.

cluaopenwrt+15
Student: Prashiddha
Code

Improvements in the DrTest tool

intermediate
Pharo Consortium•2023Varies175h (Medium)

This project proposal focuses on improving two DrTest plugins: Coverage and Executable Comment. In particular, to enhance how these plugins show the results to facilitate developer analysis by: (a) adding a statement coverage visualization view; (b) showing detailed coverage statistics; and (c) adding more grouping options in the result panel. Complementary, we propose to add a new plugin that allows developers to perform mutation testing analysis.

smalltalkroassalpolymath+7
Student: Carolina Melendez
Code
Proposal
Showing 3529 - 3552 of 11996 Projects
146147148149150
Proposal
Proposal
Proposal
Proposal