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

Radio-Browser integration

intermediate
VideoLAN•2025Varies

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)

This project aims to integrate Radio-Browser.info into VLC Media Player, allowing users to browse and play internet radio stations directly within VLC. The implementation will use the free Radio-Browser API, eliminating the need to manually search and paste stream URLs.

copenglc+++10
Student: Zyad M. Ayad
Code
Proposal

IYP Browser

intermediate
Internet Health Report•2025Varies175h (Medium)

The project enhances the IYP Browser to make the exploration of graph data more interactive and powerful. It introduces features such as node expansion on click, expandable graph views, and smart Cypher query suggestions relevant to actual IYP data. The researchers and stakeholders will benefit from improved UI controls, shareable and embeddable components, and URL-based cypher query execution. These new features will help the researchers explore and analyze networked data, get deeper insights, and make informed decisions.

pythonjavascriptapache kafka+1
Student: Ronit Jain
Code
Proposal

GSoC Proposal: AI Agent for Apache HertzBeat with MCP

intermediate
Apache Software Foundation•2025$3k–$6.6k175h (Medium)

This proposal outlines the development of an AI Agent for Apache HertzBeat using the Model Context Protocol (MCP), enabling natural language interaction with monitoring capabilities. The project will implement an MCP-compliant server and client architecture integrated with SpringAI, along with a chat-based frontend for the HertzBeat dashboard. This enhancement will make HertzBeat's monitoring features more accessible while serving as a reference implementation for AI integration in monitoring tools.

pythonjavascriptjava+7
Student: sarthakeash
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

Visual Language Models for OpenCV

intermediate
OpenCV•2025Varies175h (Medium)

This project aims to extend OpenCV’s DNN module with efficient runtime support for Large Language Models (LLMs), focusing on enabling Visual Language Models.

pythonmachine learningc+++9
Student: Oleksandr Nikolskyy
Code
Proposal

Implementing Protocol Parsers for Glutton Using Spicy

intermediate
The Honeynet Project•2025Varies175h (Medium)

This project addresses the challenge of enhancing Glutton's protocol parsing capabilities by implementing HTTP and DNS parsers using Spicy, a specialized domain-specific language for robust protocol parsing. The existing Go-based protocol handlers in Glutton will be reimagined through Spicy's grammar-based approach, creating parsers that precisely match the current implementation's behavior, including special case handling for attack vectors like Ethereum RPC exploits and Hadoop YARN vulnerabilities. The project involves the creation of a Go wrapper framework to integrate these Spicy-generated parsers with Glutton's architecture and the delivery of fully functional HTTP and DNS parsers. This work will demonstrate how specialized grammar-based protocol parsing can enhance Glutton's maintainability and extensibility while maintaining its effectiveness as a protocol-agnostic honeypot for security research.

pythonandroidmachine learning+16
Student: Suyash Handa
Code

Extension Support for pgexporter

beginner
PostgreSQL•2025Varies90h (Small)

PostgreSQL extensions can offer detailed views of query performance, storage usage, and system health but this would need frequent manual setup to be used with monitoring systems. Our proposal improves upon pgexporter through automatic detection of supported extensions and the output of pre-configured metrics for vital extensions such as pg_stat_statements, pg_buffercache, and pg_stat_monitor. It allows easy observability, diminishes the role of manual setup, and helps for optimal data-driven database performance monitoring.

cpostgresqlperl+8
Student: Bassam Adnan
Code
Proposal

Poincaré normal form of Riemann matrices

intermediate
SageMath•2025Varies175h (Medium)

The project aims to compute the Poincaré normal form of Riemann matrices in SageMath. This computation enables the decomposition of theta functions into a product of lower-dimensional theta functions, which can be evaluated much faster. The project will implement the methods described by Martens to equip SageMath with tools for detecting and performing these reductions. The solution involves finding the reduction matrix M (if it exists), computing the Poincaré normal form of M, and applying a transformation to the period matrix. We aim to deliver a SageMath module for computing M and its normal form, a function for transforming the period matrix, a fully tested implementation for Poincaré reduction, and comprehensive documentation.

pythoncython
Student: Caleb Aryee
Code
Proposal

MQTT Protocol Support for ERDDAP

intermediate
IOOS•2025Varies175h (Medium)

MQTT is a lightweight messaging protocol which is used by IoT based devices as a way to transfer data at very high speeds. Adding its support to ERDDAP™ would enable it access near real time data and build datasets with it. This project will add support for ERDDAP™ to act as both, an MQTT client to connect with existing brokers and as an MQTT broker to collect real time data from sensors.

pythonocean sciencejava+3
Student: ayushsingh01042003
Code
Proposal

Upstream Greybus Module for Zephyr

intermediate
BeagleBoard.org•2025Varies175h (Medium)

The Greybus module for Zephyr currently exists as an out-of-tree component, making maintenance, testing, and contributions difficult. This project aims to upstream Greybus as an official Zephyr module, improving maintainability, accessibility, and seamless integration within the Zephyr RTOS ecosystem. By upstreaming Greybus, BeagleConnect and other Greybus-enabled platforms will gain native support in Zephyr, removing the need for custom patches or kernel modifications. Originally developed by Google as part of Project Ara, Greybus is a lightweight, high-speed protocol designed for efficient, low-power communication across diverse hardware interfaces. While initially intended for modular smartphones, Greybus has since expanded into IoT and industrial applications, particularly in wireless sensor networks. This project will focus on cleaning up and refactoring the existing Greybus module, revamping its testing infrastructure, and ensuring compatibility with Zephyr’s CI/CD workflows. The successful completion of this work will enable seamless hardware-software interaction, making Greybus more accessible for embedded systems development within Zephyr.

cpythonlinux+11
Student: Sahil Jaiswal
Code
Proposal

Support usage of Thrust API in Clad

advanced
CERN-HSF•2025Varies350h (Large)

This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, with support for NVIDIA's Thrust library. By enabling differentiation of Thrust's GPU-parallel algorithms, Clad users will gain the ability to automatically generate gradients for CUDA-accelerated code in scientific computing and machine learning applications. The implementation will include extending Clad's source-to-source transformation engine to recognize Thrust primitives (e.g., transform, reduce), implement custom derivatives, and validate performance through real-world use cases. This work will bridge the gap between high-performance GPU computing and AD, potentially accelerating gradient-based optimization tasks by orders of magnitude.

pythonc/c++machine learning+6
Student: Abdelrhman Elrawy
Code
Proposal

Unify HTML Pages For OSIPI Output

intermediate
Open Science Initiative for Perfusion Imaging•2025Varies175h (Medium)

The OSIPI initiative has developed various open-source tools for quantitative MRI, particularly in perfusion imaging. However, the documentation for these tools is currently fragmented across multiple projects, each with different structures, styles, and rendering approaches. This inconsistency creates barriers to usability, maintainability, and accessibility. This project aims to unify OSIPI’s documentation under a single, standardized HTML framework. By utilizing modern documentation tools such as MkDocs or other static site generators, we will create a consistent, searchable, and user-friendly interface. The unified framework will streamline maintenance, improve accessibility, and enhance the overall user experience. Deliverables include: A standardized template for OSIPI documentation. Migration of existing project documentation into the new framework. Integrated navigation and search functionality across all documentation. Automated deployment pipeline using GitHub Pages or similar tools. Clear documentation and contribution guidelines for future scalability.

pythongithub
Student: Rohan Kumar Mahato
Code
Proposal

Add Text-to-Speech Support to More Games

intermediate
ScummVM•2025Varies175h (Medium)

Text-to-speech is a critical accessibility feature that is currently not present in many ScummVM engines. Adding text-to-speech to more engines can assist language learners and those with visual impairments, as well as standardize implementation of text-to-speech across engines. In this project, text-to-speech is implemented on an engine-by-engine basis by defining GUI options for text-to-speech; identifying procedures that display text, which may include objects, menus, dialogue, and other forms of text; cleaning up the text, if necessary; and feeding this text into text-to-speech. It aims to include full text-to-speech support for a variety of engines.

openglc++assembly+5
Student: Ellen Moon
Code
Proposal

Background Enrichment augmented Anomaly Detection (BEAD)– Contrastive VAE & Transformer Architecture

advanced
CERN-HSF•2025Varies350h (Large)

This project aims to enhance the BEAD framework for anomaly detection in high-energy physics by developing a new multi-stage architecture that combines a contrastive variational autoencoder (VAE) with a self-supervised transformer and multi-task fine-tuning layers. The key goal is to learn generator-invariant representations from 4-momentum vectors of background events by pretraining the VAE using generator labels (e.g., Pythia, Herwig, Sherpa). The latent variables produced are then masked and enriched with high-level physics features (e.g., MET, HT, Meff) and passed through a transformer trained to reconstruct them, encouraging deeper physics representation learning. The enhanced latent space is decoded using fine-tuning layers that perform multiple tasks simultaneously: reconstructing event-level features, predicting jet properties, and regressing unseen quantities. This structure encourages collaboration between the VAE and transformer components, increasing robustness against spurious correlations and improving anomaly detection performance. Deliverables will include: - A modular implementation of the full architecture within BEAD - Integration with tools like Weights & Biases for experiment tracking - Docker support for reproducibility - Evaluation benchmarks on synthetic datasets - Final documentation and presentation of findings at the CERN ML Forum

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

Open Source Community Sustainability

intermediate
INCF•2025Varies175h (Medium)

SustainHub is an AI-driven simulation platform designed to study and enhance the sustainability of open-source communities. It models contributors, tasks, and decision-making using reinforcement learning to mimic real-world collaboration dynamics. By integrating methods like Multi-Armed Bandits for task allocation and SARSA for adaptive learning, SustainHub provides insights into workload balance, contributor retention, and project health. The system introduces quantitative metrics such as the Harmony Index to measure long-term sustainability. Ultimately, SustainHub helps researchers and organizations design strategies for thriving, resilient open-source ecosystems.

pythonjavac+++7
Student: Vidhi Rohira
Code
Proposal

Securing Linux Storage with ACLs: Open-Source Web Management Interface for Enhanced Data Protection

intermediate
Department of Biomedical Informatics, Emory University•2025Varies175h (Medium)

Institutional departments, such as the Biomedical Informatics (BMI) Department of Emory University School of Medicine, manage vast amounts of data, often reaching petabyte scales across multiple Linux-based storage servers. Researchers storing data in these systems need a streamlined way to modify ACLs to grant or revoke access for collaborators. Currently, the IT team at BMI is responsible for manually handling these ACL modifications, which is time-consuming, error-prone, and inefficient, especially as data volume and user demands grow. To address this challenge at BMI and similar institutions worldwide, a Web Management Interface is needed to allow users to modify ACLs securely. This solution would eliminate the burden on IT teams by enabling on-demand permission management while ensuring security and reliability. The proposed system will feature a robust and highly configurable backend, high-speed databases, orchestration daemons for file storage servers, and an intuitive frontend. The proposal includes an in-depth analysis of required components, high-level and low-level design considerations, technology selection, and the demonstration of a functional prototype as proof of concept. The goal is to deliver a production-ready, secure, scalable, and reliable system for managing ACLs across multiple servers hosting filesystems such as NFS, BeeGFS, and others. This solution will streamline access control management and prepare it for deployment at BMI and other institutions worldwide, significantly reducing the manual workload for IT teams.

pythonjavascriptjava+4
Student: _Aditya_Patil_
Code

Fix S/R versions of the parallel algorithms

intermediate
Ste||ar group•2025Varies175h (Medium)

This project aims to fix critical issues in the S/R versions of HPX’s algorithms. Specifically, the parallel version of the following twelve algorithms: nth_element, partial_sort, partial_sort_copy, set_difference, set_intersection, set_symmetric_difference, set_union, shift_left, shift_right, sort, sort_by_key, and stable_sort. These algorithms currently have not passed the S/R unit tests defined in PR #6494, which undermines their reliability and efficiency in parallel processing environments. Also, for the sort_by_key, shift_left, and shift_right algorithms, their CPO (Customization Point Object) is not based on tag_parallel_algorithm, which needs further improvement.

c++cudaopencl+10
Student: Zhengnan Hua
Code
Proposal

Enhancing the SMART on FHIR Frontend for Patient-Controlled Data Sharing

intermediate
Data for the Common Good•2025Varies175h (Medium)

I will improve a SMART on FHIR patient-facing app to make it more accessible, user-friendly, and efficient. This includes simplifying menus and buttons, ensuring strong screen-reader support, and optimizing loading times. My plan involves: Research & Analysis Review the current user interface and identify usability issues. Conduct user interviews to pinpoint major pain points (e.g., confusing navigation, slow pages). Redesign & Development Rebuild the interface using React.js with clear, accessible design. Enhance features like keyboard navigation, text sizing, and screen-reader compatibility. User Testing & Feedback Invite patients to test the updated interface. Collect feedback and fix any bugs before final deployment. Documentation & Handoff Provide a developer guide and post the code on GitHub. Ensure future teams can easily maintain and update the app. Key Deliverables A revamped, accessible React.js interface. Improved user workflows and faster load times. A documented codebase on GitHub. A clear style guide and developer documentation.

pythonjavascriptkubernetes+2
Student: aryantony
Code

Proposal for Disentangled Generation and Editing of Pathology Images

intermediate
UC OSPO•2025Varies175h (Medium)

My proposal is to create and control computer-generated images of breast cancer tissues. I'll spend my first four weeks building basic models called VAEs that can learn what cancer looks like. Then I'll spend four weeks making better, sharper images using GANs. In my final four weeks, I'll try the newest technology called diffusion models to make the most realistic images. I'm using 400 real cancer tissue images that doctors have labeled from normal to severe cancer. My goal is to help train doctors and improve cancer detection systems by creating realistic fake images we can control. This matters because real cancer images are hard to get, and doctors sometimes disagree on what they see. If I succeed, my computer models will let users adjust how severe the cancer looks in an image, which could help with teaching and testing new cancer detection software.

pythonc/c++visualization+5
Student: Mingyuan Shao
Code

Cloudcasting UI

intermediate
Open Climate Fix•2025Varies175h (Medium)

Open Climate Fix recent Cloudcasting model is able to predict clouds movements very accurately but for end user it’s hard to see or visualize the results, this project aims to create a new dashboard similar to quartz-frontend that is already up and running, to visualize results from the cloudcasting model the dashboard will be build using Next.js and MapBox as base map layer, Sentry to log errors, and a minimal fastapi server written in python to preprocess zaar data and serve it to the frontend, this solution will be a proof of concept for the new MVP

pythonpytorch
Student: Suvan Banerjee
Code
Proposal

Robotic Arm Control for PSLab

advanced
FOSSASIA•2025Varies350h (Large)

This project aims to add a robotic arm control feature to the new PSLab mobile app and in the PSLab Python library, enhancing their capabilities with advanced features that go beyond basic manual servo control. I will implement a screen in the PSLab mobile app through which users can connect the robotic arm to the PSLab device and control it either manually or through automated sequences. Manual control will be provided via circular sliders with fine-tuning options, while automated control will be enabled through a timeline interface where users can create and play sequences, allowing the robotic arm to move according to the defined timeline. Users will have additional options such as selecting the timeline length, choosing the operating frequency (e.g., 50 Hz or 100 Hz), setting the maximum angle, and enabling haptic feedback at each second of the timeline. At the end of playback, the app will display a detailed summary of the timeline, including a PWM graph, to help users better understand and debug the sequence. In the PSLab Python library, I will implement a dedicated class for robotic arm control, allowing users to operate the arm by creating and executing timelines. Furthermore, I will include options to export timelines in CSV format and import them, into both the PSLab mobile app and in the PSLab Python library, ensuring that timelines can be shared and used seamlessly across platforms, thereby bridging the gap between mobile and Python-based control. I will also add proper documentation for this feature in the PSLab documentation.

pythonjavascriptandroid+7
Student: Rahul Das
Code
Proposal

Expanding OOP capabilities of LPython for porting common CPython modules

advanced
Python Software Foundation•2025Varies350h (Large)

The aim of this project is to extend LPython's OOP capabilities to enable the porting of CPython modules. The proposal is divided into three main parts: improving the utility of classes in LPython using general imports and dunder methods, porting CPython's re and json modules and addressing some miscellaneous goals like adding advanced data structures and improving string attributes.

pythonmercurialjavascript+3
Student: SwamiShiju
Code
Proposal

Generate JS Interop Bindings for TypeScript Declaration Files

intermediate
Dart•2025Varies175h (Medium)

This project proposal is for the web_generator tool to parse TypeScript Type Declaration Files and generate valid Dart JS Interop code to call the library's JavaScript code from Dart, which can be used to call and use such libraries in Dart easily and conveniently through maintainable and efficient APIs, with the power of Dart's interoperability. This is to be done using tsc to parse Type Declaration Files and provide information about such declarations passed. Then, they are transformed into valid Dart JS Interop code, which is then emitted via the code_builder package.

flutterdartprogramming-language
Student: nikechukwu
Code
Proposal

Add Docker Swarm Support to Sugar

intermediate
Open Science Labs•2025Varies175h (Medium)

This project will enable Sugar users to manage Docker Swarm clusters directly through Sugar’s command-line interface (CLI). These enhancements will streamline container orchestration workflows and make Sugar a more versatile tool for developers transitioning from development to production environments. New commands will enable users to perform tasks such as initializing, joining, creating, scaling, updating, and inspecting Swarm services with simplified Docker Swarm Node and Secrets Management.

pythonjavascriptc+++3
Student: Sai Sanjay Kottakota
Code
Proposal
Showing 2233 - 2256 of 11996 Projects
9293949596
Proposal
Proposal
Proposal
Proposal
Proposal