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

Add Text-to-Speech Support to More Games

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

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

Multimodal Intelligence: Supercharging Agents with Gemini

advanced
Google DeepMind•2025Varies350h (Large)

This project addresses critical gaps in Gemini API integration across leading agent frameworks (LangChain, LlamaIndex, CrewAI, Composio), where multimodal capabilities and function calling remain underdeveloped or inconsistent. By implementing standardized components for multimodal processing, function calling, and performance optimization, the project will democratize access to Gemini's advanced capabilities for developers building sophisticated AI agents. The implementation will follow a systematic approach, beginning with a comprehensive framework audit and gap analysis, followed by development of core multimodal support, function calling capabilities, and performance optimization layers. The solution will include a unified adapter layer that standardizes Gemini API access while respecting each framework's architectural patterns. Deliverables include: (1) enhanced framework integrations with full multimodal support, (2) standardized function calling implementations, (3) performance optimization components including token management and caching systems, (4) comprehensive documentation and examples, and (5) a benchmarking suite for performance analysis. This project will establish a new standard for Gemini integration in the agent ecosystem, enabling entirely new classes of multimodal AI applications.

pythonjavascripttypescript+2
Student: Wale
Code
Proposal

Adding Translation System for DISCOVER Cookbook

intermediate
NumFOCUS•2025Varies175h (Medium)

Currently, the Cookbook has multiple resources that can help any event became inclusive and accessible to everyone. However, its accessibility remains limited due to its exclusive support for English. This language restriction creates a barrier for a global audience, preventing many from fully benefiting from its guidance. This project aims to develop a comprehensive translation workflow for the DISCOVER Cookbook, enabling seamless multilingual support. A language selection mechanism will be integrated within the book, allowing users to easily switch between available translations. Additionally, an automated update system will be implemented to ensure translations remain synchronized as content evolves. To maintain high-quality translations, the project will engage and onboard community translators, fostering collaboration and sustainability in the translation process.

pythonjavascriptr+3
Student: Dia29
Code
Proposal

Jenkins Domain specific LLM based on actual Jenkins usage using ci.jenkins.io data

intermediate
Jenkins•2025Varies175h (Medium)

This project aims to improve Jenkins CI/CD troubleshooting by creating a domain-specific Large Language Model (LLM). The core task involves fine-tuning an open-source LLM (e.g., Phi-4/Qwen 2.5) on structured data derived from ci.jenkins.io build, logs and metadata, using resource-efficient techniques like QLoRA with Unsloth. To ensure feasibility despite potential API limitations, a primary strategy involves heuristic/manual data curation, supplemented by LLM assistance where possible. A baseline Retrieval-Augmented Generation (RAG) system incorporating Jenkins documentation will be implemented to enhance factual accuracy. Key deliverables include the fine-tuned model (GGUF for Ollama), a basic FastAPI backend, the RAG pipeline, and an evaluation report incorporating both automated metrics and qualitative mentor feedback

javascriptjavago+2
Student: Chiruu12
Code

Proposal for Revamping FOSSASIA.org with WordPress for a Modern, Maintainable Website

advanced
FOSSASIA•2025Varies350h (Large)

I propose revamping the PSLab.io website to give it a clean, modern, and professional look while ensuring long-term maintainability. The project will involve migrating the site from Elementor to Gutenberg, streamlining the editing experience and making it easier for contributors to update and manage content. By focusing on modern UI/UX design, improved performance, accessibility, and SEO optimization, the redesigned site will better highlight PSLab’s open-source hardware and software initiatives. This transition will not only improve usability for visitors but also simplify content management for the community, ensuring a sustainable and future-proof digital presence.

pythonjavascriptandroid+7
Student: Nimeshan
Code
Proposal

GNOME Control Center: Finalizing the New Printing Architecture for GNOME

intermediate
The Linux Foundation•2025Varies175h (Medium)

The latest CUPS 3.x versions support only driverless printing through the new IPP Everywhere architecture. Modern printers predominantly use driverless technology, supporting IPP printing and automatically configuring themselves via CUPS. Unlike traditional setups, these IPP printers do not require a permanent print queue. However, many printers still rely on drivers (PPD + filter). To address this, the Genome Control Center (GCC) must be adapted to support both driver-based and driverless printers. While significant progress has been made, substantial work remains before this new approach can be fully integrated into GCC. The project aims to complete all remaining tasks, ensuring a seamless user experience for GCC printers while refining all aspects for the final release.

cpythonmysql+7
Student: K_V
Code

Python API for new cell types

intermediate
INCF•2025Varies175h (Medium)

This project will involve refactoring the Human Neocortical Neurosolver (HNN-core) codebase to enable flexible development of neural circuits with customizable cell types. Currently, HNN-core contains hard-coded assumptions about cell types, locations, and connectivity that limit researchers' ability to implement networks with different architectures. I will restructure key modules to replace these hard-coded constraints with dynamic definitions, allowing users to flexibly select and connect cell types with different morphologies and electrophysiological properties. The solution involves refactoring cells_default.py for dynamic cell creation, modifying network.py to handle arbitrary cell types, and updating related components to support custom cell types. The proposed plan includes dynamic cell type implementation, updated network connectivity handling, a demonstration model with custom cell types, comprehensive documentation, and unit tests ensuring backward compatibility. This work will significantly enhance HNN's capabilities for hypothesis testing in EEG/MEG research while maintaining its user-friendly approach for neuroscientists.

pythonjavac+++7
Student: Chetan Kandpal
Code
Proposal

Better JSON Schema Errors

intermediate
JSON Schema•2025Varies175h (Medium)

JSON Schema validation errors are often cryptic and difficult to understand, making debugging frustrating for developers and end users. This project aims to develop a JavaScript library that transforms raw JSON Schema validation outputs into clear, concise, and human-friendly error messages. It will maintain compatibility with the standard format while improving error readability, supporting multiple languages, and allowing customization. By the end of the project, developers using standard-compliant JSON Schema validators will have access to a high-quality, user-centric Better JSON Schema errors—enhancing the developer experience and making debugging more intuitive for end users.

pythonjavascripttypescript+2
Student: Arpit Kuriyal
Code
Proposal

Adding clustering *Searcher classes in statistics package

advanced
GNU Octave•2025Varies350h (Large)

The GNU Octave Statistics package lacks class definitions for knnsearch and rangesearch, and its KDTree method is currently disabled due to poor performance (GitHub issue #151). This project aims to implement KDTreeSearcher, ExhaustiveSearcher, and hnswSearcher classes, along with the createns helper function, to enhance clustering capabilities. The KDTree implementation will be optimized using a compiled Octave (.oct) library for faster index construction and queries. Each searcher class will include efficient knnsearch and rangesearch methods. Deliverables include optimized implementations, extensive testing, benchmarks, and comprehensive documentation, improving performance, usability, and MATLAB compatibility.

c++hg
Student: Swayam Shah
Code
Proposal

Add npm folder for the scripts and add integration tests for this folder

intermediate
AsyncAPI•2025Varies175h (Medium)

There are many static .mdx and .json files in the codebase that are used to render pages or components on the AsyncAPI website. These static files are regularly updated by some scripts on builds and via cron jobs and my task is to refactor the scripts. Currently, some scripts contain a main function that directly executes the scripts. In this refactoring, I am removing those direct executions and instead call all script functions from a central npm folder. This will allow us to structure integration tests directly for these scripts. As a next step, I will be writing the integration tests as well for these script and fix the existing unit tests affected due to refactoring. Tech Stack: TypeScript, Data Structures and Algorithms, NPM, Testing, Unit Testing, Integration Testing, Code Refactoring, Next.Js

javascriptjavago+2
Student: Sagar Kori
Code

Rewrite Test management pages components from JSP to React

intermediate
OpenELIS Global•2025Varies175h (Medium)

The OpenELIS organization currently relies on JSP (Jakarta Server Pages) for most of its pages but is gradually transitioning to a modern JavaScript-based framework, React.js. Many pages still use Java-based controllers and endpoints to dynamically update and display data on the front end. As part of this project, I will rewrite all Test Management Pages and their components in React UI, integrating them with REST API endpoints to fetch and render data. Additionally, I will migrate all Test Management Configurations, Management, and other operational pages to React.

postgresqljavascriptjava+2
Student: Aditya Deshlahre
Code
Proposal

Ultimate Alarm Clock Companion App

intermediate
CCExtractor Development•2025Varies175h (Medium)

The project aims to develop awar s companion app for the Ultimate Alarm Clock mobile application. This companion app will allow users to sync, control and manage alarms directly from the smart watch using the Data Layer API, also lets them set alarms natively on watch and that message can be send to UAC as well.

clinuxvideo+14
Student: abhishek14104
Code
Proposal

Parallel Filter Implementation for ASP/IJ

intermediate
INCF•2025Varies175h (Medium)

The Active Segmentation Platform for ImageJ (ASP/IJ) aims to provide a general-purpose workbench that allows biologists and other domain experts to access state-of-the-art techniques in machine learning to achieve excellent image segmentation and classification. This project aims to speed up the convolution engine in ASP/IJ by implementing GPU parallelization using JCuda, a Java-based framework for CUDA. Currently, the convolution engine runs only on the CPU.

pythonjavac+++7
Student: Rikas Ilamdeen
Code
Proposal
Showing 2377 - 2400 of 13453 Projects
9899100101102
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal