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

GSoC Project Proposal for Flashrom

intermediate
Flashrom•2022$3k–$6.6k

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

The write operation in flash can only change bits in a specific way and the erase operation changes all the bits of a block to 1s. So to modify any bit the whole block needs to be copied to another memory, erased on the flash, and then copied again from the other memory with the change. Due to this “erase overhead” write operations may require copying a lot of data to modify a small amount. Most flash chips support multiple erase-block sizes and flashrom keeps a list of these sizes and ranges for all supported flash chips. Currently, flashrom tries these functions one by one and uses the same function until the operation is completed or an error occurs. Usually, the first function works correctly but this function erases the smallest erase-block so flashrom would have to use it multiple times to complete the erase operation on a large region, which could have been done more efficiently using functions using larger erase-blocks, thus resulting in a transaction overhead. If a large erase-block size to erase a small region is chosen it would result in a larger erase overhead. So the erase-block size should be picked according to the size of the region left to be erased. Also checking in advance to tell if the programmer supports the given erase function and then sorting the supported functions in order of the erase-block sizes can further help the function selection.

cx86bios+2
Student: Aarya
Code
Proposal

Tooling for detecting impact of behavioral changes in Go lib (2026 Term 1)

Intermediate
•Varies175h (Medium)

Maintenance of a stable Go library often involves value-judgement calls regarding what changes can impact downstream consumers. While some existing tooling like apidiff can go some way towards preventing breakage, these tools work purely in terms of API-level breakage such as changing the type of a symbol. Inspired by tooling in other language ecosystems such as Rust this proposal sets out to build a tool that can give statistical information about the impact of any change on downstream consumers by running the build pipelines and test suites of dependents before and after a particular change. This would empower maintainers to make better informed choices about changes and foster an ecosystem. We think this is specially important for the OpenTelemetry project since the OpenTelemetry Go modules and the OpenTelemetry Collector modules are foundational modules used within the CNCF on other projects (e.g Kubernetes, Jaeger) as well as outside of it. The intent is to build a tool that could be used as well by other CNCF projects since Go is the *lingua franca* of the foundation, enabling all projects to have a flourishing ecosystem. - Expected Outcome: We would like to have a tool written in Go that is able to (i) gather all publicly-listed dependencies of a module, (ii) safely run the test suite of dependencies for a given version of the code and (iii) compare two test suites and provide a statistical summary of the differences between the two to help in decision-making.

TBA
Proposal

imzML Parser in OpenMS

advanced
OpenMS Inc•2026Varies350h (Large)

Mass spectrometry imaging (MSI) is a powerful analytical technique that enables spatial mapping of molecules within biological tissues. The imzML format is the open standard for storing MSI data, consisting of an XML metadata file and an associated binary data file. OpenMS currently lacks native support for reading and writing this format. The goal of this project is to implement a robust imzML parser in OpenMS, enabling seamless integration of mass spectrometry imaging data into existing OpenMS workflows and applications. The proposed solution already demonstrates the ability to load and parse both continuous and processed imzML formats, including support for large datasets. The implementation has been benchmarked against pyimzML for validation and consistency. This project will further extend the work by integrating with OpenMS Python bindings (currently under development), while identifying potential challenges and outlining strategies and solutions to address them. Tasks: Implement a C++ imzML reader capable of parsing both continuous and processed imzML formats Develop an imzML writer to support exporting imaging data Add support for essential imzML metadata, including spatial coordinates, pixel size, and spectrum-level parameters Integrate the parser with existing OpenMS data structures (e.g., MSExperiment, MSSpectrum) Write comprehensive unit tests and validate functionality against reference imzML datasets Document the implementation and provide clear usage examples.

pythoncythonc+++2
Student: Aditya Sarna
Code
Proposal

Implement IVFFlat indexing strategy for MariaDB Vector and evaluate the performance

advanced
MariaDB•2024Varies350h (Large)

implementing the IVFFlat indexing strategy for MariaDB Vector to enhance performance. including support of key features like support different distance metrics, and support choosing between HNSW and IVFFLAt.also optimizations on the searching time building indexer time, and benchmarking metrics.

cmysqlmariadb+7
Student: Ahmed Sayed Sayed Madbouly
Code
Proposal

MAC policy on IP addresses for FreeBSD Jail

intermediate
FreeBSD•2019Varies175h (Medium)

<p>With the introduction of <strong>VNET(9)</strong> in FreeBSD, Jails are free to set their IP addresses. However, this privilege may need to be limited by the host as per its need for multiple security reasons.</p> <p>This project uses <strong>mac(9)</strong> for an access control framework to impose restrictions on FreeBSD jails according to rules defined by the root of the host using sysctl(8). It involves the development of a dynamically loadable kernel module(<strong>mac_ipacl</strong>) based on <strong>The TrustedBSD MAC Framework</strong> to implement a security policy for configuring the network stack.</p> <p>This project allows the root of the host to define the policy rules to limit a jail to a set of IP(v4 or v6) addresses and/or subnets for a set of interfaces.</p> <p>The features of the mac_ipacl policy module are-</p> <ul> <li>Host is able to limit the restrict the desired jail to particular IP addresses(or subnets).</li> <li>Host can the restrict the certain jail from setting certain IP address or prefixes.</li> <li>Host can enforce the policy for a particular network interface(or all interfaces) for a jail.</li> <li>sysctl interface for tuning the mac_ipacl module.</li> </ul> <p>Apart from the module, Proper Test Suite (with ATF and Kyua) and a man page for the mac_ipacl is also part of the project.</p>

c/c++llvmshell script+4
Student: Shivank Garg
Code
Proposal

Refactor syscall creation script

intermediate
The FreeBSD Project•2024Varies175h (Medium)

The current FreeBSD system call creation script was implemented to streamline the introduction of system calls into the FreeBSD kernel. It’s a monolithic script, converted from awk to Lua, and has kept much of the procedural-oriented awk code. It does not take full advantage of modern features of Lua (object-oriented design) and is difficult to extend. The goal is to strip the current script into an easily extendable interface. It will utilize classes to give extensible methods to objects, mainly utilizing the facade and command design patterns, to give a more "bite-sized" interface to the previously procedural code. This will allow easier maintenance of the Lua tables and procedures, and a better platform to add more. Lua modules will provide better namespacing of globals, dynamic generation of output files, and more modules with different tasks may be easily added. After refactoring, the previous functionality of the original script can be achieved simply by calling the necessary modules. The benefit to FreeBSD is further streamlining in the creation of system calls, a more maintainable interface, and a strong foundation to build upon in the development of future system call creation tools. It will further demystify the process of system call creation and allow others to more easily contribute. Deliverables are (1) system call creation will work as before; (2) the monolithic script will be refactored into core, modules, and classes; (3) a system call creation library that is easily extensible; and (4) well-documented with conventions used.

c/c++llvmassembly+5
Student: agge3
Code
Proposal

Improve RISC-V software ecosystem verification Mentorship Project

Intermediate
•Varies175h (Medium)

"The evolution of KVM (Kernel-based Virtual Machine) unit tests from a virtualization testing framework to one that also encompasses bare metal testing allows us to build a comprehensive unit test framework for Supervisor Binary Interface(SBI) in RISC-V. The need for a standalone, comprehensive unit test framework for SBI has become increasingly evident. Validation of the SBI specification has traditionally been intertwined with feature implementations across OpenSBI, KVM, and the Linux kernel. By establishing a dedicated unit test framework, we aim to streamline the identification and rectification of bugs early in the development cycle, thereby ensuring a robust and reliable specification for RISC-V's growing ecosystem. The RISC-V support along with a few SBI extensions got merged[1] recently, which enabled basic SBI extensions and SMP/EFI support in kvm-unit-tests for RISC-V. Expanding the coverage of both existing and forthcoming SBI extensions is critical to accelerating the development and adoption of the SBI specification. Besides generally improving kvm-unit-tests, tests for the following SBI extensions may be added: SBI PMU support Bare Metal testing using OpenSBI firmware Virtualization testing with KVM SBI Steal time extension support Virtualization testing with KVM SBI Debug Trigger extension Bare Metal testing using OpenSBI firmware Virtualization testing with KVM Any other extensions (SUSP, MPXY ?) CoVE related tests (time permitting)

TBA
Proposal

Enabling LLM fine tuning in the WASI-NN ggml plugin (2024 Term 2)

Intermediate
•Varies175h (Medium)

WasmEdge is a lightweight and cross-platform runtime for LLM applications. It allows developers to create LLM apps on a Mac or Windows dev machine, compile them to Wasm, and deploy them on Nvidia machines without any changes to the binary app. It achieves application portability across CPUs and GPUs by supporting a W3C standard API called WASI-NN (https://github.com/second-state/wasmedge-wasi-nn), which abstracts GPU-related AI functions as high-level APIs. At this stage, however, only inference functions are supported. In this project, we aim to support fine-tuning features in WasmEdge. It will improve the developer experience for WasmEdge-enabled LLM tools. To achieve this, we plan to extend the current WASI-NN spec by adding a set of extra APIs, and then implement them by delegating to corresponding functions in llama.cpp embedded in the WasmEdge GGML plugin. Expected Outcome: 1. Use llama2-7b as the base LLM for fine-tuning; the final implementation should handle it correctly. 2. Extend the WASI-NN (https://github.com/second-state/wasmedge-wasi-nn) spec if needed to support the fine-tuning feature. 3. Implement the fine-tuning functions inside WASI-NN ggml plugin. They will call the corresponding functions in llama.cpp, as the inference functions do. 4. Implement the LoRA-related functions inside the WASI-NN ggml plugin to load the pre-trained LoRA and verify the fine-tuned model. 5. Documentation, examples, tutorials, and demonstration are required.

TBA
Proposal

Adding functionalities to medical imaging visualizations

intermediate
The Julia Language•2024Varies175h (Medium)

MedEye3D.jl aims to enhance medical imaging visualization within the Julia language ecosystem. The current proposal addresses the need for improved functionality in windowing, support for the display of super voxels, faster load times, and robust viewing of multiple images. By leveraging Rocket.jl and ModernGL.jl, the proposal plans to implement features like enhanced windowing for MRI and PET data, support for the display of super voxels, and high-level functions for improved user experience. The project aims to streamline visualization processes and provide essential tools for 3D medical imaging workflows. The main deliverables include: Supporting simultaneous visualization of multiple registered medical images, with linked scrolling, cursor highlighting, and connecting lines between annotated points across images. Implementing automatic windowing and colormaps for common MRI and PET imaging modalities to provide consistent visualizations mimicking other medical imaging software. Adding support for visualizing supervoxel segmentations with boundary detection using techniques like the Sobel filter. Improving startup time by precompiling critical components of the package. Implementing high-level functions to simplify basic usage by abstracting away low-level details of image loading, rendering, and visualization. By enhancing MedEye3D.jl with these features, the project aims to provide a more comprehensive and user-friendly tool for 3D medical image visualization and analysis within the Julia ecosystem. The improvements will facilitate better integration into medical imaging workflows and enable more efficient exploration and interpretation of data across different modalities.

cjavascriptc+++12
Student: Divyansh Goyal
Code

LDAP Capture Capabilities

intermediate
Metasploit•2023Varies175h (Medium)

This project aims to deliver a module to add capture capabilities over the LDAP protocol. This module will allow the capture of LDAP traffic and logging of the captured information like authentication information. The logged information can be used by other auxiliary and post-exploit modules to perform future actions.

crubyasm+3
Student: JustAnda7
Code
Proposal

Improving AI Data Pipelines in AIDRIN: A Privacy-Centric and Multimodal Expansion

intermediate
UC OSPO•2025Varies175h (Medium)

AIDRIN (AI Data Readiness INspector) is an open-source tool designed to assess the quality, fairness, and readiness of datasets before they are used in AI workflows. However, its current implementation supports only basic evaluations for tabular data and lacks both privacy-aware assessments and the ability to handle unstructured data formats like images. This project proposes to address these limitations in two structured phases. In Phase 1, I will enhance AIDRIN’s capabilities for tabular datasets by implementing essential privacy-preserving metrics—such as k-Anonymity, l-Diversity, t-Closeness, MM Risk Score, and Entropy-Based Disclosure Risk—alongside other key checks for class imbalance, feature correlation, and model evaluation. These assessments will be supported by intuitive visualizations to help users make informed decisions about data quality and compliance. In Phase 2, I will extend AIDRIN to support image datasets by integrating pretrained vision models to generate semantic embeddings. These embeddings will enable readiness evaluations such as duplicate and outlier detection, class imbalance analysis, completeness checks, and fairness diagnostics (when label or attribute metadata is available). The goal is to replicate AIDRIN’s structured readiness evaluation pipeline for visual data in a modular and reusable manner. Deliverables include: Privacy and imbalance metric suite for tabular data with visual summaries Embedding-based readiness evaluation pipeline for image datasets Integration with pretrained vision models (ViT, CLIP, DINOv2) CLI tool for executing and exporting assessment results Documentation, testing, and demonstration notebooks By the end of the program, AIDRIN will support robust and privacy-aware readiness assessments for both structured and unstructured datasets, helping researchers and practitioners build more transparent, reliable, and ethical AI systems.

pythonc/c++visualization+5
Student: Harish Balaji
Code

Assignment Suite & Classroom Workflow Enhancement

intermediate
CircuitVerse.org•2026Varies175h (Medium)

CircuitVerse provides a powerful digital logic simulator, but its classroom workflow lacks critical features required for effective teaching at scale. Currently, instructors cannot organize students into structured teams, assign collaborative work, reuse pre-built circuit templates, or rely on modern LMS integrations due to outdated LTI 1.1 support. These limitations lead to inefficient grading, repeated manual setup, and poor integration with platforms like Canvas. This project aims to enhance CircuitVerse’s classroom ecosystem by introducing four key improvements. First, a subgroup system will enable instructors to divide students into teams with defined roles, supporting structured collaboration. Second, group-based assignment workflows will allow submissions on behalf of a team, ensuring consistent grading and reducing redundancy. Third, a circuit template library with integrated test cases will enable reusable, pre-configured assignments and automated grading using a simulation-based evaluation pipeline. Finally, the project will upgrade LMS integration by implementing LTI 1.3 using OpenID Connect and OAuth 2.0, enabling secure authentication, deep linking, and modern grade passback via Assignment and Grade Services (AGS). The deliverables include: A fully functional subgroup and team management system with API support Group assignment workflows with submit-on-behalf functionality A template library with auto-grading using simulation-based test cases Complete LTI 1.3 integration including OIDC login, deep linking, AGS score submission, and NRPS roster access Comprehensive RSpec test coverage and documentation By addressing these gaps, this project will transform CircuitVerse into a scalable, LMS-integrated teaching platform capable of supporting modern classroom workflows and institutional requirements

postgresqljavascriptbootstrap+8
Student: @magic-peach
Code

Project #2: Robotics Academy: consolidation of drone based exercises

advanced
JdeRobot•2022Varies350h (Large)

Currently there are 11 drone exercises available, all as web-templates (RoboticsAcademy v3.2). The goal of this project is to consolidate the existing exercises, improving front-end appealing and extending drones back-end (PX4 and JdeRobot drone-wrapper) with new functionalities, such as adding support to new control methods or new sensors (IR sensors, depth cameras, etc) If time permits, the project may also explore the development of new drone exercises or extending support to real drones.. Work will be done with Docker, Gazebo-11 and ROS-noetic. Also, ROS2 use for these exercises will be explored. This work will possibly be done in the mentorship of Mr. Pedro Arias and Mr. Arkajyoti Basak. Deliverables Deliverable 1 Strengthening of current drone based exercises with bug crushing and optimised template (before Evaluation 1) Deliverable 2 Development of better and appealing frontend with broadened and extended drones backend through addition of support for new functionality like sensors and new control methods (by Evaluation 2) Deliverable 3 Pre development base for the new drone exercises & extension for support of real drones and exploration of ROS2 for these exercises (if time allows) (by the end of the coding period) Approach ● Creating an additional folder with several subfolders containing all the necessary scripts to beta test the optimised template. ● Running the exercises in search for details regarding existing bugs ● Improve the appeal of frontend through HTML document cleanup, optimising CSS performance, minifying CSS, Javascript & HTML ●Improving PX4 performance for multiple drones and additional HAL methods for controlling drone(s) through nosing around PX4, creating necessary scripts for packages. ● Adding new gazebo models for new sensors and interfacing them with the Robot’s brain with the HAL ● RADI (RoboticsAcademy Docker Image) launch shell script has to be updated additional requirements

pythonrosgazebo+2
Student: Prakarsh Kaushik
Code
Proposal

Implementation of Singularity Functions to solve Beam Bending problems

intermediate
SymPy•2016Varies175h (Medium)

<p>My proposal aims at designing and implementing a singularity functions module in a pure mathematical way. This module is further utilised in implementing a module which would only focus on solving beam bending problems. There will be a CAS implementation of the singularity functions and some high level abstractions for solving beam bending problems.</p>

pythonc++numpy+1
Student: Sampad Kumar Saha
Code
Proposal

Continue the Development of the x86_64 BSP

intermediate
RTEMS Project•2024Varies175h (Medium)

This project seeks to advance the development of the x86_64 BSP by implementing ACPICA support, Symmetric Multiprocessing, Floating Point support and Thread Local Storage support. Additionally, it involves the addition of a BSP tester for the rtems-test tool, with the ultimate goal of ensuring the BSP successfully passes all tests in the test suite.

cpythonembedded systems+5
Student: Matheus Pecoraro
Code
Proposal

Swift/ObjC compatibility tool

intermediate
Dart•2024Varies175h (Medium)

Dart can interact with Swift modules annotated with @objc annotation. If a user wants to interact with an unannotated Swift module (that they don’t own), they will have to write a wrapper module annotated with @objc to expose its APIs to dart ffi. Since this can be a rather tedious task, the idea is to build a tool to generate these wrappers automatically.

flutterdartprogramming-language
Student: Mohammad3id
Code
Proposal

Python Argentina: <PyZombis project> Continue the implementation of the course in the Runestone environment

intermediate
Python Software Foundation•2021Varies175h (Medium)

<p>Continue the implementation of the course with Runestone components. Currently, some exercises are not working due to the Python modules they use. I have in mind replacing them with other modules. The expected outcome is to have the existing lectures implemented in Runestone fully functional with various exercises with automatic grading, have created new lectures teaching other modules, and have implemented other lectures using Brython.</p>

pythonmercurialjavascript+3
Student: Leonardo Cumplido
Code
Proposal

JPEG 2000 Decoder improvements

intermediate
FFmpeg•2020Varies175h (Medium)

<p>FFMPEG has a native JPEG2000 decoder. However, the decoder is incomplete and does not support all types of JPEG2000 files. The aim of this project is to make the native JPEG2000 decoder comprehensive and allow it to support all types of JPEG2000 files. Additionally, the project aims to add support for code linked to the JPEG2000, such as RTP encoding/decoding, J2K stream parsing, etc.</p>

cgitasm+3
Student: Gautam Ramakrishnan
Code
Proposal

Remote-Write v2 in otel-collector's prometheusremotewriteexporter (2024 Term 3)

Intermediate
•Varies175h (Medium)

Prometheus recently [announced the second version of it's remote-write protocol](https://prometheus.io/docs/specs/remote_write_spec_2_0/), with support for new features on top of performance and cost savings. The work to be done is contribute support for this new protocol in the OpenTelemtry-Collector-Contrib repository, more specifically to the `prometheusremotewriteexporter` component. Expected Outcome: `prometheusremotewriteexporter` component with support for PRW v2.

TBA
Proposal

Rewriting Esoteric, Error-Prone Makefile Tests Using Robust Rust Features

beginner
The Rust Foundation•2024Varies90h (Small)

tests/run-make contains a heaping collection - 349 to be precise - of Makefiles containing ancient and difficult to understand test scripts. As a result, Rust maintainers may struggle to understand why these tests fail and how to patch their code appropriately. This project aims to rewrite these tests in robust, documented rmake.rs files, backed up by a supportive and easy to understand run-make-support support tool.

pythonrust
Student: Julien Robert
Code
Proposal

Agora Library Improvement

advanced
AOSSIE•2024Varies350h (Large)

Agora is a high performance vote counting library written in Scala. The library currently supports several vote counting algorithms, however it is quite outdated and doesn't have support for Scala 3. Rewrite library using Scala 2.13 and provide support for Scala 3.x Make Candidate and Ballot generic Implement tie resolution algorithms and add possibility for users to include theirs

pythonjavascriptswift+8
Student: Angafor Brandon Njenewone
Code
Proposal

Image PrePull Feature Enhancement (2024 Term 1)

Intermediate
•Varies175h (Medium)

In the latest release, KubeEdge has implemented the ability for image pre pull. However, each task execution only supports images from the same image repository currently. We hope to enhance this feature to support capabilities like overriding images and secrets, complete end-to-end tests for this feature. Expected Outcome: Support image and secret override in image pre pull feature. And E2e tests for this feature are added.

TBA
Proposal

swhkd: Provide Libinput as an Alternative Input Backend

intermediate
Waycrate•2025Varies175h (Medium)

This project aims to replace the current backend of swhkd, which uses evdev, to replace it with libinput. Libinput provides better support for common devices that interact with a desktop interface, this can with getting better input handling support and fix issues like debouncing, mouse acceleration, etc which cannot be handled directly by evdev. The final deliverable would be a version of swhkd with an alternative libinput backend, whichs supports all the features of swhkd.

cc++rust+2
Student: Aadil
Code
Proposal

Containerization And Deployment Of Apache Fineract CN Using Docker, Docker Compose And Docker Swarm

intermediate
The Mifos Initiative•2018Varies175h (Medium)

<p>Apache Fineract CN is an Application Framework for Digital Financial Services. It is a system to support nationwide financial transactions and to support the creation of an inclusive, interconnected digital economy for every nation in the world. Currently Apache Fineract CN supports any client device and connect to legacy data and processes via APIs, I propose to containerize and deploy this system on the cloud using Docker, Docker Compose and Docker Swarm.</p>

mysqljavascriptandroid+5
Student: Courage Angeh
Code
Proposal
Showing 2977 - 3000 of 5976 Projects
123124125126127
Proposal
Proposal
Proposal