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

Cross-Platform SCM Support for Scrum Helper

intermediate
FOSSASIA•2026Varies

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)

Scrum Helper currently supports only GitHub and a partially-integrated GitLab, with all platform logic tightly coupled in a 2,190-line monolithic file. This makes adding new SCM platforms nearly impossible without duplicating the entire data-fetching flow. This project refactors Scrum Helper's core into an extensible Provider Pattern architecture by defining a standardized SCMProvider interface that decouples platform-specific API calls from the report generation engine. I will then implement native providers for GitLab (including self-hosted instances), Gitea, and Bitbucket, each returning normalized data through a unified schema. Deliverables: (1) SCMProvider interface with normalized data models, (2) Refactored GitHubProvider with full regression coverage, (3) GitLabProvider with self-hosted baseUrl support, (4) GiteaProvider tested against Codeberg, (5) BitbucketProvider with OAuth 2.0 auth, (6) unified caching and cross-provider error handling, and (7) architecture guide and contributor docs for adding future providers. All 4 platforms will generate identical scrum reports by project end.

pythonjavascriptandroid+7
Student: Kaung Hset Hein
Code
Proposal

Liquid Galaxy: Ubuntu LTS System Migration - Ubuntu 16.04 to Ubuntu 24.04

intermediate
Liquid Galaxy project•2026Varies175h (Medium)

Liquid Galaxy is an open-source panoramic multi-display system used in museums, universities, and science centers worldwide. Its entire installation infrastructure install.sh and all supporting configuration files was written for Ubuntu 16.04 LTS, which reached End of Life in April 2021. As a result, Liquid Galaxy cannot be installed on any currently supported Ubuntu version, leaving existing deployments without security patches and blocking new ones entirely. This project is a systematic, layer-by-layer migration of Liquid Galaxy to Ubuntu 24.04 LTS (Noble Numbat). Rather than patching each broken line individually, I will introduce an OS abstraction layer a lib/ directory of functions that encapsulate every OS-dependent operation, from network detection and display manager configuration to package management and service control. This ensures the system can survive future Ubuntu LTS releases without requiring a full rewrite each time. Deliverables: 1) Updated install.sh working end-to-end on Ubuntu 24.04 2) lib/ OS abstraction layer with testable, version-aware functions 3) GitHub Actions CI pipeline 4) Post-install smoke test suite 5) MIGRATION.md, TROUBLESHOOTING.md, and updated README.md with complete architecture documentation.

javascriptrosgis+14
Student: Mahmoud Mohammed
Code

Extending C++ Support in GCC Static Analyzer

intermediate
GNU Compiler Collection (GCC)•2026Varies175h (Medium)

GCC's static analyzer (-fanalyzer) lacks C++ class hierarchy awareness, causing it to miss bugs in exception catch blocks that use base types and limiting virtual function resolution. This project implements exception subclass matching (PR119697) and improves virtual function dispatch (PR97114) by adding type hierarchy infrastructure to the analyzer.

cc++openmp+3
Student: Egas Ribeiro
Code
Proposal

AI/ML to Enhance and Streamline Manual/TA Grading

intermediate
Submitty•2026Varies175h (Medium)

This project develops an intelligent clustering system that groups student submissions by similar patterns, algorithmic approaches, and correctness levels. The system enables TAs to efficiently manage large-scale grading while maintaining fairness and consistency. Problem: TAs face repetitive, time-consuming grading of similar submissions with risk of inconsistency and human error, especially in large courses (100+ students). Solution: Automated clustering of submissions using hierarchical agglomerative clustering with interactive dendrogram visualization. TAs can merge/split/reject clusters, bulk apply feedback templates, and flexibly grade (bulk or individual). Key Deliverables: - Feature extraction engine (68-dim for code, 389-dim for text) - Hierarchical clustering with Ward linkage - Interactive dendrogram UI for TA manipulation - Bulk feedback application system with per-student customization - Flexible grading modes (bulk, individual, hybrid) - Comprehensive testing and documentation Expected Impact: 80-90% reduction in grading time while improving consistency and feedback quality. Time savings: 45 submissions graded in 15 minutes vs 225 minutes without clustering.

pythonc++databases+5
Student: GarvitKhandelwal
Code
Proposal

Quantum Circuit Design with LLMs

advanced
Machine Learning for Science (ML4SCI)•2026Varies350h (Large)

Variational quantum circuits are essential for near term quantum algorithms but designing them involves complex manual trial and error. This project solves this bottleneck by creating an automated agentic framework using Large Language Models to synthesize and optimize quantum circuits. By interacting with quantum simulators in a closed loop the AI agent will debug circuits and minimize gate depth automatically. The main deliverables include custom Orchestral AI tools for quantum simulators an iterative feedback pipeline for hyperparameter tuning and comprehensive benchmarking to uncover novel gate sequences.

pythonmachine learningc+++2
Student: Tomoya Hatanaka
Code
Proposal

Agentic Cognitive Firewall SDK

advanced
C2SI•2026$6k–$13.2k350h (Large)

LLM agents built with LangGraph and LangChain retrieve documents, call tools, and write to memory - but nothing validates what enters the model's context. A poisoned RAG document can hijack an agent's behaviour. A malicious tool parameter can exfiltrate data. A single memory write can silently alter every future response. There's no standard security layer for any of this. ACF-SDK is a Zero Trust firewall that sits between the agent and the LLM - intercepting every input across four hooks (prompt, context, tool call, memory) and enforcing policy-as-code decisions through an isolated Go sidecar. I want to take this pipeline from hardcoded ALLOW to real enforcement: upgrade the semantic scanner to catch paraphrased attacks, wire scanner signals into the real sidecar, build memory write protection with HMAC and provenance tracking, ship a Docker demo anyone can clone and run in 5 minutes, and stress-test the whole system against adversarial evasion techniques with a technical evaluation report. The foundation is already built. I've shipped 6 PRs - semantic scanner, benchmark harness, LangGraph adapter, Rego policy templates for all four hooks, audit logger, and a Go scan stage implementation. 155 tests passing. GSoC wires these components into a running system and proves they hold up under real attacks.

pythonjavago+2
Student: Pranjal Udhwani
Code
Proposal

Add support for 3D thermal simulations in PyBaMM

advanced
NumFOCUS•2025Varies350h (Large)

Seeing the current increasing demand of high performance batteries, accurate thermal modelling of battery behaviour is essential. This project extends PyBaMM by adding the capability to simulate battery temperature in three dimensions. It starts by developing 3D meshes (box, cylinder etc) and FEM method. Then we develop a 3D thermal model for batteries, initially assuming a constant heat source. This thermal model is then coupled with existing battery models (like the SPM or DFN) so that the heat generated during battery operation can be simulated. The model will also eventually allow temperature data from the thermal simulation to feed back into the battery model, enabling more realistic, two-way interactions.

pythonjavascriptr+3
Student: Rishab Kumar Jha
Code
Proposal

State-Space Models: Dynamic Factor Models

advanced
NumFOCUS•2025Varies350h (Large)

State-space models (SSMs) provide a flexible framework for modeling dynamic systems where latent states evolve over time. In econometrics, Dynamic Factor Models (DFMs) are widely used to capture the co-movement of multiple time series by assuming that a small number of latent factors drive the observed variables. The PyMC library already includes implemen- tations of SARIMAX, VARMAX, and structural state-space models, along with example notebooks for their usage. This project aims to extend the existing PyMC state-space module by implementing Dynamic Factor Models, aligning with the functionality available in statsmodels. Our implementation will follow a Bayesian approach, leveraging PyMC’s probabilistic programming framework and PyTensor for computation. Additionally, an accompanying example notebook will demonstrate estimation, forecasting, and causal analysis with the new model, ensuring accessibility for users. This enhancement will significantly expand PyMC's capabilities, empowering student, practitioners and researchers in econometrics, macroeconomics, and beyond to model complex time-series data probabilistically.

pythonjavascriptr+3
Student: Andrea Catelli
Code
Proposal

Improving the SweetCam IP camera honeypot

advanced
The Honeynet Project•2025Varies350h (Large)

Problem: IP cameras are frequent targets for cyberattacks due to their widespread use and often weak security. Current honeypots like SweetCam lack comprehensive protocol support and realistic emulation, limiting their effectiveness in detecting and analyzing threats. Solution: This project aims to transform SweetCam into a versatile, multi-protocol honeypot by: 1. Expanding protocol support for RTSP and ONVIF, enabling deeper interaction with attackers. 2. Introducing template-based device emulation using YAML to simulate real-world cameras (e.g., Dahua, Hikvision). 3. Improving usability with Docker enhancements, automated configuration, and a realistic HTTP interface featuring error simulation and multi-language support. Deliverables: 1. A production-ready SweetCam with RTSP/ONVIF support and 5+ device templates. 2. Optimized Docker deployment (multi-stage builds, Compose profiles). 3. Enhanced HTTP interface (login flows, error simulation, i18n). 4. Comprehensive documentation, including setup guides and protocol specifications. Impact: This upgrade will equip researchers and defenders with a powerful tool to study attacker behavior, improve IoT security, and contribute to the broader honeypot ecosystem.

pythonandroidmachine learning+16
Student: c1nk
Code
Proposal

Batch Processing Gateway Integration

advanced
Kubeflow•2025Varies350h (Large)

Jupyter Notebooks provide a powerful, interactive environment widely used by data scientists and ML engineers for exploratory analysis, visualization, and prototyping. However, as the scale and complexity of data workloads grow, running computations locally within notebook pods becomes inefficient and limiting. The Batch Processing Gateway integrates with Kubeflow Spark Operator to manage the full lifecycle of Spark applications in a cloud-native environment. It enables distributed computation at scale and automates job deployment, resource management, and status tracking using Kubernetes Custom Resource Definitions (CRDs). This project proposes integrating Jupyter Notebooks and the Batch Processing Gateway, enabling it to manage the notebook kernel lifecycle of remote Spark kernels as distributed Spark applications. This decouples computation from the notebook pod and scales Spark workloads efficiently in Spark. To achieve this, we will introduce Batch Processing Gateway to manage the lifecycle of Notebook kernels and introduce Jupyter Enterprise Gateway (JEG) for runtime communication to enable Jupyter messaging protocol for notebook cell execution during runtime.

pythontensorflowkubernetes+5
Student: Fellipe Resende
Code
Proposal

A Diffusion-Based Deep Learning Framework for Denoising Protoplanetary Disk Observations

intermediate
Machine Learning for Science (ML4SCI)•2025Varies175h (Medium)

This project proposes ProtoDiff, a diffusion-based deep learning model designed to denoise astronomical observations of protoplanetary disks from telescopes like ALMA and VLT. Leveraging recent advances in score-based generative modeling, the model will be trained on synthetic disk simulations with realistic noise. ProtoDiff aims to outperform traditional denoising pipelines in both quality and efficiency, enabling cleaner reconstructions of planet-forming environments. The final deliverables will include open-source code, pretrained models, and documentation to support reproducible astrophysical data processing and accelerate research in planet formation studies.

pythonmachine learningc+++2
Student: Chukwunwogor Faithful
Code
Proposal

Implement consistency check for refs

intermediate
Git•2024Varies350h (Large)

The project addresses the issue that the current git-fsck command cannot detect corruption in the "packed-refs" file and lacks explicit checks for the ref database, especially with the introduction of the new "retable" backend format. The solution involves creating an infrastructure that allows for backend-specific consistency checks for refs. This will include checks for both the existing "file" backend and the new "retable" backend. The project will leverage Git's polymorphism in handling refs to ensure that all ref names are conformant and to prevent directory/file conflicts among ref names. Additionally, it will ensure the "packed-refs" file is well-formatted and that refs are ordered lexicographically. Deliverables for the project include the infrastructure setup for backend-specific checks, implementation of generic ref checks, and unit tests to ensure correctness. The project is expected to take 175 to 350 hours, depending on whether checks for the "retable" backend are implemented.

cshell scriptgit+2
Student: shejialuo
Code
Proposal

imputeTestbench for multivariate time series

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

The goal of this project is to modify the imputeTestbench package to work with multivariate time series data from multiple domains, and to improve its computational performance. Specific objectives include: 1. Understand the concept of the existing imputeTestbench package and other time series AutoML tools. 2. Adapt imputeTestbench to work with multivariate time series data. 3. Improve the performance of imputeTestbench by switching to data.tables and integrating with Apache Spark, and by introducing parallel processing. 4. Embed state-of-the-art imputation methods into imputeTestbench. 5. Use the R shiny package to create a dashboard for the package to make it easier to use and display output more intuitively

cc++r+4
Student: Pranay Agrawal
Code
Proposal

Glyph Map Visualization

intermediate
R project for statistical computing•2024Varies175h (Medium)

Currently Glyph maps are implemented in the cubble package. The goal of this project is to develop ggplot2 extensions to expand support for more types of Glyphs than what is currently available. The deliverables for this project include the code repository for a new glyph ggplot2 extension, tests, and extensive documentation on the usage of the functions I create.

cc++r+4
Student: Nathan Yang
Code
Proposal

Interactive graphics for the tourr package using Python

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

The tourr R package enables users to explore shapes of high-dimensional data to gain further insight into their data of interest. This is achieved by visualizing low(er) dimensional projections of the data. As tours aren’t just singular projections, but rather sequences of projections, an integral part of the tourr package focuses on animating tours. In its current implementation, the package doesn't offer interactivity to guide the tours towards projections of particular interest. Previous efforts have been made to add interactivity; however, the resulting software suffered from performance issues or didn't provide the desired level of interactivity. Python packages such as matplotlib or tkinter offer the desired interactivity at a high efficiency. The primary goal of this project is to develop software that seamlessly integrates the interactivity available through Python with the tourr package written in R. To achieve that, the packages reticulate and rpy2, which provide tools for interoperability between Python and R, will be used. Furthermore, a wrapper for the tourr package will be developed in Python that will make tourr more accessible to the Python community. Finally, a technical documentation as well as a vignette for the developed code will be produced.

cc++r+4
Student: mmedl
Code

FaustNet: Enabling ML in Faust

advanced
GRAME•2024Varies350h (Large)

This proposal bridges the gap between audio processing and machine learning by introducing an automatic differentiation (AD) library for the Faust programming language. This library empowers audio engineers to leverage machine learning within their familiar Faust environment. The core of the library will be pre-defined building blocks. These include Faust primitives with built-in derivative functions for common math and audio processing tasks. Additionally, there will be helper functions to simplify program construction and various loss functions specifically suited for audio processing. The proposal also explores Faust Neural Net Blocks (FNNBs), which are pre-written code modules representing specific neural network functionalities. These FNNBs will save development time, improve code maintainability, and allow audio engineers to focus on network architecture rather than low-level programming for each layer. The project deliverables will showcase the utility of the AD library in various phases. Phase I will deliver a working example of a differentiable filter or envelope in Faust. Phase II will focus on implementing a full-scale machine learning algorithm. This will be achieved through an autodiff file and a weights file. Finally, Phase III and IV will deliver an autoencoder implemented using FNNBs. By combining the AD library, FNNBs, and an architecture file specifying the training process, users can design and train complex neural network models for audio processing tasks entirely within Faust. This eliminates the need to switch between Faust and separate machine learning frameworks, while offering the benefits of automatic differentiation for efficient model training.

cpythonjavascript+3
Student: Advik Basani
Code
Proposal

Maintain and Port Sugar activities to Flatpak

intermediate
Sugar Labs•2023Varies175h (Medium)

A number of Sugar activities are bundled with Flatpak as a way to reach a broader audience within the Linux community. This project aims to keep those activities up to date and also port new sugar activities to Flatpak, including the two popular activities Pippy and Physics.

pythonjavascriptgtk++10
Student: Sparsh Goenka
Code
Proposal

Google Summer of Code Community Hub

intermediate
rocket.chat•2023$3k–$6.6k175h (Medium)

Every year, it is understandable that open-source organisations invest a significant amount of time and effort in preparing for GSoC. That's why the Google Summer of Code Community Hub will act as an essential tool to help prepare and support every organisation before and during the program. The GSoC Community Hub is designed to be a one-stop-shop for open-source groups to interact, collaborate, and monitor their progress before and during GSoC. It provides an all-in-one platform that combines chat rooms, forums, custom leaderboard, community meetings, communication over specific GitHub repositories, and other essential features, making it easier for mentors and mentees to find and collaborate on relevant projects.

javascriptwebrtcmeteor.js+18
Student: M. Palanikannan
Code
Proposal

Implement Escape Analysis in Julia Compiler

intermediate
The Julia Language•2021Varies175h (Medium)

<p>Escape analysis is a classic problem in compiler analysis. Julia compiler has an existing AbstractInterpreter framework for managing inter-procedural analysis of type through data-flow analysis. But the existing framework has very limited support for escape information.</p> <p>In this project, we are implementing escape analysis via extending the current framework or via implementing a new framework and integrating it into the compiler. With better escape information collected, we are able do more kinds of optimizations including converting heap objects to stack objects and scalar optimizations.</p>

cjavascriptc+++12
Student: Xuanda Yang
Code
Proposal

glTF virtual environment loading

intermediate
xrdesktop•2021Varies175h (Medium)

<p>Virtual desktops look nice with a comfortable environment round them. This project allows the user to use a glTF file as their custom xrdesktop environment and adds more features to the gulkan library to add support for better-looking scenes.</p>

cvulkanwayland+2
Student: sin3point14
Code
Proposal

Apache Camel - OAI-PMH Component

intermediate
Apache Software Foundation•2020Varies175h (Medium)

<p>This proposal aims to implement an OAI-PMH component for Apache Camel. OAI-PMH is a protocol widely used in libraries and digital repositories across the world. This implementation will be extremely useful for final users working on data integration this domain.</p>

pythonjavascriptjava+7
Student: Juan Segarra
Code
Proposal

Command palette, Command Stack and Macros

intermediate
Inkscape•2020Varies175h (Medium)

<p>Inkscape comes with a plethora of features out of the box, and functionality can be extended even more by using various extensions. These features and extensibility have made Inkscape the wonderful software it is today. But, these features come with a cost, i.e. difficulty accessing these features. Currently, operations have to be searched through highly nested and huge drop-downs. Also, you have to remember where the option was. Keyboard shortcuts don't solve the problem due to their learning curve, system shortcuts, and the limit on the number of keys that can humanly be pressed. Command Palette(CP) is an interactive search bar that can search any operation (extensions, edits, filters, etc.) that Inkscape provides. CP is also a tool for the <strong>power users</strong> It speeds up the access times by using commands that help users to bypass the slow GUI and use mostly their speedy keyboards. Another problem is repetition. The ordered nature of most drawings calls for repetition. As we know Inkscape is a tool for creative people and nothing kills creativity faster than repetition. Macros are a way to record your actions and repeat them. Command Stack provides a GUI way to make macros.</p>

pythonc++css+6
Student: Abhay Raj Singh
Code
Proposal

Improving Purr Data encapsulation techniques

intermediate
Purr Data•2020Varies175h (Medium)

<p>Currently, Purr Data has two basic techniques of encapsulating parts of the program, mechanism that provides a way to organize and modularize the programs. One is copying part of the diagram and pasting it into a subpatch. This hides the part of the diagram inside the subpatch and shows up as a single object in the parent patch. The other way is using “abstractions”, which are external Pd programs that are instantiated as objects on the working patch. However, these two techniques present some problems for developers. The goal will be to improve these two techniques to make them more friendly and less arduous for developers and to speed up the whole process, that is always wanted.</p>

javascriptc/c++node.js+9
Student: Guillem Bartrina
Code
Proposal

Google Cloud IoT Core Interface in Lua

beginner
LabLua•2019Varies90h (Small)

<h5>The project consists of developing an interface, in Lua, for the set of Cloud IoT Core APIs, through two REST resources:</h5> <ul> <li>cloudiot methods, to facilitate device manager tasks</li> <li>cloudiotdevice methods, to facilitate device communication over the HTTP bridge </li> </ul> <h5>The Proof of Concept</h5> <ul> <li>Another task is to provide a Proof of Concept by using a real world device such as NodeMCU/Raspberry Pi interfaced with temperature sensor to send the temperature data over to the Google Cloud IoT Core. </li> <li>Doing the reverse, sending the data to the device using the Google Cloud IoT Core. We expect this data to be a Code Snippet, which would run dynamically on the device every time it is interrupted by the new code received.</li> </ul> <h5>Development of a software interface with REST support in Lua</h5> <ul> <li>With a minimal GUI this application will make the life of a person using Lua REST APIs easier by providing a simple interface to send and receive data from an endpoint.</li> <li>Testing would be done using the Proof of Concept developed above.</li> </ul>

luacéuelasticsearch+5
Student: Gaurav Kumar-1
Code
Proposal
Showing 1345 - 1368 of 13453 Projects
5556575859
Proposal
Proposal