Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
11996 Projects Found
Sort by

Add safety contracts

intermediate
The Rust Foundation•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)

There is ongoing work to instrument the Rust standard library with safety contracts. Based on a discussion by the Formal Verification Working Group there is still a lot of work to leverage the power of separation logic in contracts, and make it compatible with existing tools that use separation logic. The nature of my contribution would be more research-oriented, since a very good understanding of the connection between separation logic, existing tools and what we can and need to support in Rust contracts is necessary. Based on this research, a successful project should deliver the appropriate code contributions to support (partially or fully) separation logic in Rust contracts, and ideally demonstrate its compatibility with existing tools by tackling selected challenges in the Verify Rust Std Lib project.

pythonrust
Student: Dawid Lachowicz
Code
Proposal

Modernize the 3D Model Repository

intermediate
OpenStreetMap•2025Varies175h (Medium)

3DMR is a community-driven repository for 3D models and their metadata, designed to enhance 3D map rendering. It was originally developed during Google Summer of Code 2017 by Pedro Amaro, under the mentorship of the OpenStreetMap community, with Jan Marsch and Tobias Knerr serving as mentors. Since then, the project has been left largely abandoned and now runs on an outdated Django 2.0.5 codebase. This proposal aims to revive 3DMR by modernizing its foundation—upgrading the framework, adopting glTF as the standard model format, and introducing a range of improvements including robust model validation, enhanced preview functionality, and automated quality analysis feedback.

javascriptjavaopengl+10
Student: Ayush Dhar Dubey
Code
Proposal

imputeTestbench for multivariate time series

advanced
R project for statistical computing•2025Varies350h (Large)

The imputeTestbench package offers an automated framework to benchmark various imputation techniques on univariate time series. It has been widely used in research for its ability to simulate missing data scenarios and evaluate multiple methods side-by-side. However, its current scope is limited to univariate data and lacks the performance and flexibility needed for more complex real-world applications. This project proposes a major upgrade to the imputeTestbench package by extending its capabilities to multivariate time series, improving its computational performance, and adding a modern, interactive user interface via Shiny. The new version will also support advanced imputation techniques, including machine learning and deep learning-based approaches, and provide options for distributed computation using tools like Apache Spark.

cc++r+4
Student: Seema_Kumari
Code
Proposal

Completion of UI using React.js

advanced
FOSSology•2025Varies350h (Large)

This project aims to complete and modernize the React-based UI of FOSSology by aligning it with the updated REST API v2 and current frontend best practices. The work includes finalizing the incomplete interface, upgrading React to 19.1.0 for improved performance and concurrency, and migrating from yarn to pnpm for faster, space-efficient development. It will also implement UX improvements from the FOSSology UX and UI redesign project and create a reusable component library with Storybook. Comprehensive documentation and deployment guidelines will be provided to ensure long-term maintainability and contributor onboarding.

linuxpostgresqlc/c+++7
Student: Tiyasa Kundu
Code
Proposal

ABDM – Patient Centric Flows (PHR Flows)

intermediate
Open HealthCare Network•2025Varies175h (Medium)

This project implements comprehensive patient-facing digital health capabilities in the CARE platform by integrating Ayushman Bharat Digital Mission (ABDM) Personal Health Record (PHR) flows. While CARE currently supports provider-side health information exchange through the existing ABDM module, it lacks patient-centered features that would allow individuals to access and control their health data. My solution builds a complete set of APIs and interactive user interfaces to bridge this gap by implementing seven key components: ABHA Enrollment - Digital identity creation with multiple verification methods Profile Login - Secure multi-channel authentication and session management User Profile Management - Personal health information control and preferences Discovery and Linking - Finding and connecting fragmented health records Subscriptions & Notifications - Automated health updates and alerts Consent Management - Granular control over data sharing permissions Health Record Display - Unified view of medical history across providers The implementation seamlessly integrates with the existing ABDM module while adding complementary PHR capabilities, enabling CARE to function effectively in dual roles—as both a provider-focused clinical system and a patient-centered health record platform. Deliverables include a fully functional implementation of all ABDM PHR APIs, an intuitive and responsive patient portal interface, comprehensive transaction tracking for compliance, and thorough documentation. All components will adhere to healthcare security and privacy standards while providing a cohesive user experience. The completed project will transform healthcare delivery by eliminating information gaps between providers and empowering patients as active participants in their care journey.

pythondjangoreact+2
Student: Siva Pidugu
Code
Proposal

Enhance mysqltest Language with Expressions and Variable Substitutions

intermediate
MariaDB•2025Varies175h (Medium)

The mysqltest tool is a core component of MariaDB’s testing infrastructure. Currently, it has two limitations that restrict the flexibility and expressiveness of test scripts: 1. Limited Variable Substitution: The tool only supports basic variable access patterns. 2. Lack of Expression Support: It lacks support for arithmetic, comparison, and boolean operations. This project addresses both limitations by implementing SQL-like function support and expression evaluation to the mysqltest language. It also enables users to write more concise, maintainable, and powerful test scripts while ensuring backward compatibility with existing tests.

cmysqlmariadb+7
Student: Khaled Riyad
Code
Proposal

Multi-Agent Traffic Optimization + Infrastructure improvements.

advanced
Open Robotics•2025Varies350h (Large)

I am Ryan, a college student finishing their last semester for a bachelors in computer science. My contribution to the multi-agent traffic optimization project would be to take the lessons I’ve learned from my previous bevy projects, and use them to update and improve rmf_site’s infrastructure over the course of several stages, and to use those improvements to add procedural generation for the tests sites that will then be used for multi-agent optimization testing. The stages for this would be as follows: 1. bevy 0.12 -> latest version of bevy + library updates.. 2. Compile time improvements 3. Debug tool improvements 4. test scenario automation through procedural generation. Update everything: The first thing to do would be to update rmf_site bevy and all other dependencies to their latest versions. I’ve done this for all my projects since bevy 0.11, and I can do it for rmf_site too. Improve Compile TImes: The next step would be improving compile times. When I tested this project on my local machine. Iterative compile times took around 50 seconds. With the appropriate restructuring of crates, slimmer crate imports, more granular feature flags, and the introduction of the mold linker, these recompile times could be cut down to around 2-7 seconds. Improve debug tools: After that, then comes adding more debug tools. We can add bevy_inspector_egui for bevy entity/component inspection, bevy_tracing for performance optimization via Tracy. Automate test scenarios: Lastly, would be adding procedural generation for test sites. First, would be adding initial tests with randomized prefab placement, then moving to procedural room layouts from tiles, then assigning different layout kinds to each of these, (storage room, office room, etc..), and then finally connecting these different layouts together into a single site.

pythonc/c++ros+5
Student: rydb
Code

Integrate Mifos X with Workflow Engine/Process Automation Tool

intermediate
The Mifos Initiative•2025Varies175h (Medium)

As stated in the Mifos Forge, Users of Mifos have long had a need to have greater control and flexibility over creating loan and customer onboarding workflows that incorporate internal processes/steps as well as processes involving external systems. This project would center around creating an external integration with a workflow engine such as Flowable or jBPM using the Mifos X REST API as the glue. The auto-generated client library from the back-end enforces the contract between the workflow engine and the core banking system. The core banking and its REST API act as the glue. The result would be a UI-driven workflow engine to allow non-technical users to define these new custom workflows, where they could drag and drop the different steps of the process.

mysqljavascriptandroid+5
Student: Hossam Hatem Ragab
Code

Enhancing OpenCV's imgcodecs Module Code Refactoring and Feature Improvements

advanced
OpenCV•2025Varies350h (Large)

The goal of this project is to improve OpenCV’s imgcodecs module by reducing code duplication, enhancing performance, and improving format support. Deliverables: Modular and maintainable imgcodecs module. Faster, more efficient image I/O. Improved support for modern image formats and metadata. Robust and complete JPEG XL implementation with animation.

pythonmachine learningc+++9
Student: Suleyman Turkmen
Code
Proposal

Complete microservices infrastructure for FOSSology

advanced
FOSSology•2025$6k–$13.2k350h (Large)

This project aims to complete the microservices infrastructure for FOSSology by continuing the work from GSoC 2021, with a goal to fully deploy FOSSology on Kubernetes. Over the past few years, multiple changes have been made to the codebase and the build system, requiring updates and integration strategies. Key deliverables include: - Reviewing and aligning the legacy GSoC Kubernetes setup with the current codebase - Completing pending work from pull request #2086 - Providing a fully working FOSSology Kubernetes deployment - Creating comprehensive documentation for Kubernetes setup - (Stretch Goals): Creating a single setup script, implementing health checks, and exposing usage/performance metrics This project ensures easier deployment, better scalability, and modern DevOps practices for FOSSology’s infrastructure.

linuxpostgresqlc/c+++7
Student: M.Salman
Code
Proposal

HR Management module

intermediate
Open HealthCare Network•2025Varies175h (Medium)

The goal of this project is to develop an HR management module for the CARE system, streamlining employee management and automating leave and holiday tracking. The platform enables HR to efficiently manage employee records, process leave requests, securely handle document uploads, manage holidays, and allows employees to apply for leave and access their profiles and leave history.

pythondjangoreact+2
Student: Gurukiran
Code
Proposal

Json Library for D

advanced
D Language Foundation•2025Varies350h (Large)

D’s current JSON libraries (e.g., Phobos’s std.json) rely heavily on dynamic typing, which sacrifices type safety and performance—critical drawbacks for systems programming. For example, parsing JSON data into a generic JSONValue container forces developers to manually validate field types and existence at runtime, introducing overhead and error-prone code. This project addresses these limitations and enables type-safe JSON processing with constant memory by building higher-level functionalities on top of jsoniopipe, which exemplifies the language’s strengths in compile-time function evaluation(CTFE) and introspection.

linuxmaked+2
Student: Fei
Code
Proposal

Implement Signature Help for Haskell Language Server

intermediate
Haskell.org•2025Varies175h (Medium)

Haskell language server (HLS) implements the server part of Language Server Protocol (LSP) to improve user experience of reading and writing Haskell. Signature help is a LSP language feature which shows function signatures and documentation when the cursor is inside a function application. It can also highlight part of the signature related to the current parameter the cursor is at. Users want this useful feature. This project implements signature help for HLS.

haskellghccabal+3
Student: linj
Code
Proposal

Optimizing Retrieval-Augmented Generation Pipelines for Accurate and Efficient Q&A Systems

intermediate
Scala Center•2025Varies175h (Medium)

This project aims to bring the power of Retrieval-Augmented Generation (RAG) into the Scala ecosystem by building a robust Scala interface to interact with RAG pipelines. I will design a Scala-compatible wrapper to connect with Python-based components like FAISS and Hugging Face Transformers via gRPC or HTTP APIs. The project will also include developing idiomatic Scala modules for preprocessing, querying, and evaluating textual data, making it easier for Scala developers to integrate RAG into NLP or search applications. By providing seamless interoperability and modular architecture, this will empower the Scala community to build intelligent, language-aware systems more efficiently.

#scala#scala_lang#jvm+7
Student: GOPI TRINADH MADDIKUNTA
Code
Proposal

Regression Data Dashboard and HDF Writing Capabilities of TARDIS Modules

beginner
TARDIS RT Collaboration•2025Varies90h (Small)

TARDIS implements a regression testing framework which is used to compare the current output of TARDIS to a saved data repository to validate code. This data repository is modified at times when there are code/infrastructure changes in TARDIS, this could be environment updates, scientific code changes or more. However, the impact of smaller commits goes unnoticed. There is a comparison notebook implemented that can compare two different commits and spectra in a comprehensive manner but that does not provide a way to compare multiple commits at once. This project aims to build a system to compare the regression data produced by a range of TARDIS commits and will be able to find the commits which impact the regression data files. Also this project aims to enhance TARDIS HDF writing capabilities by adding a HDF writing system to most TARDIS objects and the simulation, so it is easy to reproduce TARDIS objects from stored HDF files.

pythonnumbanumpy+2
Student: Riddhi Gangbhoj
Code

LLMSeqRec: LLM Enhanced Contextual Sequential Recommender

intermediate
UC OSPO•2025Varies175h (Medium)

In today's world sequential recommendation systems are used in various domains-- from life sciences to e-commerce and business. For example, within biology and ecology, recommendation systems help track a species behavior by suggesting research on migration patterns, and within e-commerce these systems are used to better a user's online experience. As such, recommendation systems are vital to systems today and is a important field of research. Despite widespread use, traditional sequential recommendation systems face limitations. They primarily on historical user interactions to predict future preferences however struggle to capture contextual dependencies and adapting to dynamic user behaviors. Similarly, existing models predefined embeddings which restrict the ability to adapt and generalize. As such these problems lead to reduced recommendation accuracy, typically for example in cold-start users. As such, the LLMSeqRec proposal will lead to a more personalized recommendation by interpreting and augmenting sequences with semantic context. Through this, LLMSeqRec can make up for the traditional difficulties-- making more accurate and adaptable recommendations personalized for each user.

pythonc/c++visualization+5
Student: connorlee
Code
Proposal

Improving the DICOMHawk medical honeypot

intermediate
The Honeynet Project•2025Varies175h (Medium)

DICOMHawk is a honeypot system designed to emulate a vulnerable DICOM (Digital Imaging and Communications in Medicine) server, primarily to detect, analyze, and understand malicious activity targeting healthcare infrastructure. This project proposes a set of enhancements aimed at improving its operational effectiveness, observability, and deployment experience. The plan involves integrating CanaryToken webhooks to enable deception-based detection of unauthorized file access, refining the logging system with structured and enriched logs to support real-time threat monitoring, and optimizing the Docker configuration to follow best practices for security, automation, and resource efficiency. These technical enhancements will be supported by thorough documentation, testing, and monitoring setup using tools like ELK stack. Together, these contributions aim to make DICOMHawk more robust, extensible, and easier to deploy while contributing meaningfully to the field of threat intelligence in healthcare cybersecurity.

pythonandroidmachine learning+16
Student: Anshikaa Sharma
Code

Color sensor for Music Blocks for photos and real-time video.

intermediate
Sugar Labs•2025Varies175h (Medium)

Music Blocks has a feature to detect the color of pixels generated from drawing within the program, but it cannot detect the color of pixels from images that are either uploaded or from a webcam. By adding a feature to detect color from both uploaded images and a live webcam stream, users would be able to implement Lego music notation for the blind and similarly interactive programs. The goal of the project is to develop extended functionality to our existing tools of turtle/mouse glyph movement and limited color detection to sense color from uploaded images, as well as the real-time feed from a webcam. Upon successful implementation, the turtle/mouse glyph will be able to detect the color of pixels underneath it, regardless of whether those pixels were drawn by the turtle/mouse itself, part of an uploaded image stamped to the canvas, or part of a live webcam video feed into Music Blocks. One test of success is to run our Lego music notation for the blind project with a live feed. The result should be able to playback and record the abstract brick notation based on its contrasting colors.

pythonjavascriptgtk++10
Student: ShubhamSingh1
Code
Proposal

Fullstack cloud deployment for NiiVue

beginner
INCF•2025Varies90h (Small)

NiiVue is a versatile tool for visualizing and handling neuroimaging data, but insufficient documentation creates friction in using it in deploying workflows. This makes it challenging for developers to integrate, reducing the usability of NiiVue. As demand grows for secure and efficient web-based processing, this project aims to provide a demo that helps developers implement and customize cloud providers and analysis tools for scalable, secure neuroimaging workflows. This project will develop a full-stack solution for scalable neuroimaging analysis, integrating client-side preprocessing with Niimath and visualization using NiiVue. A PostgreSQL database will be designed to manage neuroimaging tasks and results. Two backend approaches will be tested: one using Flask with Nipype to interface with neuroimaging tools like FSL and FreeSurfer, supporting parallel processing, and another using Flask with containerized neuroimaging tools managed via Docker orchestration (Kubernetes/ECS) for greater flexibility. The system will be deployed on AWS with secure infrastructure, including EC2 and S3, ensuring data security through encryption and access control. A minimal demo will showcase the workflow using FSL BET or FreeSurfer, accompanied by clear documentation for easy replication and deployment by developers with their own cloud provider.

pythonjavac+++7
Student: Thuy T. Dao
Code
Proposal

Matrix Archiver (libretto)

intermediate
MetaBrainz Foundation Inc•2025Varies175h (Medium)

The current logging system for Matrix communications at MeB relies on an unmaintained IRC-based bot (BrainzBot) that logs messages to a PostgreSQL database and displays them on chatlogs.metabrainz.org. While this system works, it uses outdated technology with known vulnerabilities, doesn't support many of Matrix's features and is no longer suitable as Metabrainz' primary communication platform. This project proposal replaces BrainzBot with a new archival service that archives messages directly from Matrix to HTML files and a PostgreSQL database. It will support Matrix features like message editing, reactions and media, and provide full text search over all messages. Both historical and new messages as they come in will be archived.

pythonjavascriptperl+8
Student: Jade Ellis
Code
Proposal

Improve Dora-Lerobot Demo Tutorial and Support additional hardware

beginner
dora-rs•2025Varies90h (Small)

Lerobot is a framework for rapidly developing embodied intelligent robots, which includes classic imitation learning strategies such as ACT and Diffusion Policy, as well as low-cost robot hardware. It is necessary to combine it with dora. Recently, support for the SO-ARM100, a low-cost robotic arm, was added to Dora through its driver. However, there is currently no end-to-end tutorial available for using this arm. Tutorials and documentation are critical for making the project more accessible to new users. The goal of this project is to improve the Python-based tutorial for using the SO-ARM100 robotic arm with Dora-LeRobot, enabling users to easily get started and contribute to the ecosystem. Expected Outcomes: 1.Fix issues and add missing code so that Dora-LeRobot can be run with SO-ARM100 successfully. 2.Writing detailed setup and usage tutorials. 3.Implementing code for calibration, control, training, and inference. 4.Creating video tutorials and improve based on community feedbacks. 5.Creating test plan for user testing to ensure the tutorial is easy to follow. 6.Developing the Rust library for UR5 control. A well-documented, efficient, and effective Rust library that interfaces with UR5 robots through Dora.

pythonrosc+++2
Student: Xiang Yang
Code
Proposal

Adding handy features and UI improvements to Flamenco

beginner
Blender Foundation•2025Varies90h (Small)

Flamenco, whose target audience is small studios of artists and Blender users, could benefit by adding features that enhance the user-friendliness and speed up the workflow. The main features to be implemented for this project are: 1) a configuration editor page with simple form inputs that lets users visualize, edit, and save the settings directly to/from the YAML file 2) a mass deletion function for unneeded/unwanted render jobs and 3) UI-related bug fixes to improve the overall user experience.

cpythonopengl+3
Student: Vivian Leung (vivz753)
Code
Proposal

Advanced symbol resolution and reoptimization for clang-repl

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

Clang-REPL is an incremental compiler that enables interactive programming in C and C++, combining the flexibility of a REPL with the performance of compiled languages. Currently, users must manually load dynamic libraries when Clang-REPL encounters unresolved external symbols. This project aims to improve the user experience by implementing an Auto-Loading mechanism that automatically loads the required libraries when missing symbols are detected. In addition to auto-loading, the project will introduce Runtime Re-Optimization using Profile-Guided Optimizations (PGO). By collecting profiling information at runtime, Clang-REPL will be able to re-optimize initializers dynamically, leading to better performance without user intervention. Deliverables: 1. An Auto-Loading system that seamlessly resolves missing external symbols. 2. Runtime Re-Optimization support based on profiling data to improve execution performance.

cllvmc+++3
Student: Sahil Patidar
Code

Refactoring in order to reduce Git’s global state

intermediate
Git•2025Varies175h (Medium)

Git currently relies on a global object the_repository and several global environment-related variables, which limits modularity and complicates long-term maintainability. This project aims to refactor Git’s environment handling by relocating global variables into more appropriate repository-specific contexts, primarily struct repository and struct repo_settings. However, some global variables are only relevant to specific subsystems. In such cases, instead of placing them in the repository structure, they will be moved into subsystem-specific contexts that better reflect their scope. Overall, the project will reduce global state and improve the maintainability and modularity of the codebase.

cshell scriptgit+2
Student: Ayush Chandekar
Code
Proposal
Showing 1753 - 1776 of 11996 Projects
7273747576
Proposal
Proposal
Proposal
Proposal
Proposal