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

Browser-Based Graphical Interface for JuliaBUGS

advanced
The Julia Language•2025$6k–$13.2k

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 →
350h (Large)

JuliaBUGS is a modern Julia implementation of the classic Bayesian Inference using Gibbs Sampling — BUGS language for Bayesian modeling, combining BUGS’s intuitive model specification with Julia’s high-performance sampling methods like Hamiltonian Monte Carlo. This project proposes a browser-based graphical model editor for JuliaBUGS, enabling users to visually construct probabilistic graphical models by adding nodes and drawing arrows, instead of writing code. Built using React with TypeScript and React Flow, the web interface will support adding, connecting, grouping, and editing random variables and deterministic nodes via an interactive canvas. Users can specify probability distributions and hyperparameters through intuitive forms. The editor will export model structures to JSON and generate valid JuliaBUGS (or BUGS) code. The GSoC project will focus entirely on delivering a polished, user-friendly frontend with clear usage examples and tutorials. Inspired by tools like DoodleBUGS (for WinBUGS or MultiBUGS), shinystan, and the R Package causact, this editor aims to make model specification more accessible and streamline the Bayesian modeling workflow.

cjavascriptc+++12
Student: Shravanpuri Goswami
Code
Proposal

PersonalAIs: Generative AI Agent for Personalized Music Recommendations

intermediate
Open Technologies Alliance - GFOSS•2025Varies175h (Medium)

PersonalAIs: Generative AI Agent for Personalized Music Recommendations This project aims to enhance music streaming experiences by building an AI agent that offers emotionally intelligent, personalized music recommendations. Traditional recommendation systems often overlook users’ real-time emotional states. To address this, we propose a full-stack solution that uses large language models (LLMs), emotion detection, and Spotify API integration to tailor music suggestions based on users’ mood and preferences. Key deliverables include: • A conversational chatbot UI for user interaction • Emotion detection using LLMs • Integration with Spotify for real-time user data • A hybrid recommendation system (recall & rank) based on listening behavior and emotional context • A frontend-backend architecture for seamless user experience This project will deliver a working prototype capable of understanding user emotions and musical tastes, and recommending tracks that resonate with the user’s current mood.

pythonmysqljava+7
Student: Ke Ye
Code

Enhanced Benchmark for Evaluating Intuitive Physics Understanding in Gemma Multimodal Models

advanced
Google DeepMind•2025Varies350h (Large)

This project aims to develop a more rigorous and focused evaluation testbed than that used by Garrido et al. (2025), with the specific goal of assessing the intuitive physics understanding of Gemma models. By addressing key shortcomings in existing evaluations—such as overreliance on textual outputs, limited control over task difficulty, and incomplete coverage of fundamental physical concepts—this new benchmark will enable more accurate and fair comparisons. Ultimately, it will offer deeper insights into what Gemma models actually grasp about the physical world and guide future improvements in their design and training.

pythonjavascripttypescript+2
Student: lucas-maes
Code
Proposal

Migrate IHR API

advanced
Internet Health Report•2025Varies350h (Large)

The Internet Health Report (IHR) REST API provides access to all results displayed on the IHR website. This project modernizes the API by replacing its legacy Django 2.2.27 implementation with FastAPI. All endpoints are migrated to FastAPI, while deprecated and unused code is removed to reduce complexity and improve maintainability. Additionally, the application is containerized with Docker to provide a consistent, portable runtime environment across different deployment setups.

pythonjavascriptapache kafka+1
Student: Ibraam Nashaat Rezkalla
Code
Proposal

Enhancing Developer Experience Through Automation and Workflow Optimization

advanced
Open Food Facts•2025Varies350h (Large)

Open Food Facts (OFF) relies on contributions from a global community of developers and volunteers. However, setting up development environments, navigating complex CI/CD pipelines, and contributing to multiple repositories like off-server, robotoff, and smooth-app can be time-consuming and frustrating—especially for newcomers. This project aims to streamline the entire contributor journey by creating a unified, cloud-powered Developer Experience (DevX) platform for OFF.\n \n We will implement pre-configured Google IDX, Gitpod and Codespaces environments, enabling contributors to start coding within minutes. The CI/CD pipelines will be optimized to run only affected modules, significantly cutting build and test times. We'll also create a live, versioned documentation pipeline, integrate AI-powered tools for issue triage and PR review, and develop a metrics dashboard for maintainers to track workflow efficiency.\n \n Deliverables include: \n - Deployment staging environment with Docker swarm or Ansible.\n - Auto-launch Gitpod/ Codespace environments. \n - Optimized CI/CD workflows with modular test execution. \n - Automated documentation site using OpenAPI Spec + MDX + Fumadocs. \n - AI bot integration for issue triage. \n - A real-time DevX dashboard. \n \n This project will empower contributors to go from zero to green PRs faster, making OFF development more accessible, efficient, and scalable.

androidmachine learningmongodb+6
Student: Jagjeevan Kashid
Code

Adding QCOW2 compressed image support to mkimg(1)

intermediate
The FreeBSD Project•2025Varies175h (Medium)

mkimg(1), a FreeBSD tool used for creating disk images in various formats, currently lacks support for creating compressed QCOW2 images. This project aims to extend mkimg by adding support for generating QCOW2 images with compression enabled, reducing FreeBSD's reliance on external tools for this functionality and improving the system's self-sufficiency in image creation workflows.

c/c++llvmassembly+5
Student: Christos Komis
Code
Proposal

Legacy Compatible prototype of a Rich Text Editor

advanced
Learning Equality•2025Varies350h (Large)

This project replaces Kolibri Studio's editor with a TipTap/ProseMirror solution that maintains Markdown support while improving reliability, accessibility, and performance. The modern implementation delivers core formatting through a schema-based architecture, reducing bundle size by 60% for better performance on low-end devices. It solves immediate needs while future-proofing content creation.

pythonjavascriptdjango+1
Student: Habiba Ayman
Code
Proposal

Keploy Dashboard - Modular Metrics Visualization Platform

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

Building upon a comprehensive Proof of Concept (POC) [https://poc-frontend-beta.vercel.app/] developed before the GSoC application, this proposal aims to transform the existing prototype into a robust, open-source dashboard solution for Keploy. The project will leverage the foundation of the POC repositories (Backend: github.com/Swapnendu003/poc-backend, Frontend: github.com/Swapnendu003/poc-frontend) to create a comprehensive platform that transforms complex software development metrics into intuitive, customizable visualizations. By developing a modular, real-time dashboard with advanced widget systems, intelligent data processing, and flexible template configurations, the project will empower development teams to gain unprecedented insights into their code merge and test activities. Utilizing Next.js, Go, and modern web technologies, the dashboard will provide a scalable, extensible tool that adapts to diverse project needs, offering real-time updates, in-depth analytics, and a user-friendly interface for tracking and analyzing software development performance.

javagolangnode+4
Student: Swapnendu Banerjee
Code
Proposal

Port FatFS to RTEMS with Benchmarking

beginner
RTEMS Project•2025Varies90h (Small)

The focus of this project is porting FatFS to RTEMS, offering a smaller, simpler alternative to the existing custom DOS FS file system. The project will also encompass extending previous benchmarking efforts, developing integrated benchmarking tools within RTEMS, and evaluating the newly ported file system using that tool.

cpythonembedded systems+5
Student: Sepehr Ganji
Code
Proposal

IIO Driver for ADE9113

intermediate
The Linux Foundation•2025Varies175h (Medium)

Create a Linux IIO driver for Analog Devices, Inc.'s ADE9113 Isolated, Sigma-Delta Analog to Digital Converter. Upstream the driver and associated device tree documentation.

cpythonmysql+7
Student: abhinjai
Code
Proposal

Improving Configuration Cache in key Gradle plugins

advanced
Kotlin Foundation•2025Varies350h (Large)

This project focuses on enhancing Gradle’s Configuration Cache compatibility across widely used Gradle plugins. Configuration Cache is a performance feature that allows Gradle to reuse the results of the configuration phase between builds, significantly reducing build times. However, many plugins are not fully compatible with it due to issues such as accessing project APIs at execution time or relying on non-cacheable inputs. The project aims to identify gaps by analyzing popular plugins such as Nebula and Liquibase to detect incompatibilities with Configuration Cache, then fix these issues by refactoring plugin code to eliminate non-cacheable operations and ensure tasks only rely on properly declared inputs and outputs while avoiding illegal access during execution. In addition, configuration cache tests will be introduced to validate cache correctness and guarantee future compatibility, ultimately resulting in faster and more reliable builds for developers.

gradlekotlinjvm+3
Student: Nouran Atef
Code
Proposal

Porting Chebfun to GNU Octave

intermediate
GNU Octave•2025$3k–$6.6k175h (Medium)

I propose to work on the following project: porting the Chebfun package to GNU Octave. Chebfun is a numerical computation package for MATLAB that provides a framework for representing functions in a symbolic manner using ”Chebyshev technology”, a term coined by the package authors to describe the use of Chebyshev polynomials to represent functions up to machine precision. GNU Octave is supposed to be mostly compatible with MATLAB, so Chebfun should ideally work without change on the former, but there are some slight differences and unimplemented features in Octave that make this difficult. Primarily, the main issue is that Octave’s support for object-oriented programming (classdef) is not as feature complete and as stable as MATLAB’s, which is a major problem since Chebfun is written in classdef. The goal of this project is to port Chebfun to GNU Octave, and to make it work as a dropin replacement for the MATLAB version. Since fixing classdef is not a feasible/recommended goal for a GSoC project, I will instead focus primarily on making the necessary changes to the Chebfun codebase to make it work in Octave. Along the way, I will compile new information about the status of classdef in Octave, and I will share my findings with the Octave developers, and perhaps aid in some changes to the Octave codebase itself.

c++hg
Student: Thomas Kolman
Code
Proposal

Enhancing AI Primitives in Neovim

beginner
Neovim•2025Varies90h (Small)

Neovim currently lacks built-in support for AI features. As a result, plugin developers need to reimplement the same core functionalities again and again. This leads to duplication and inconsistencies in the plugin ecosystem. This project aims to introduce AI-friendly primitives to streamline AI plugin development. It should add support for inline completion, buffer status indicators, a standardized progress API, and enhance prompt buffers with multiline support to be more friendly toward building AI-assisted workflows. These improvements should make it easy to integrate AI capabilities in Neovim while keeping Neovim performant, lightweight, and extensible as always.

cpythonjavascript+4
Student: Shadman Saleh
Code
Proposal

Implementing Multi-page Folio Support in OpenAFS Linux Kernel Module

advanced
OpenAFS•2025Varies350h (Large)

This project enhances the OpenAFS Linux kernel module with multi-page folio support, addressing a key performance limitation in the current implementation. OpenAFS currently interacts with the Linux kernel's memory management system through single-page operations, despite recent kernel versions offering folio APIs capable of managing multiple contiguous pages as a single unit. I will implement comprehensive multi-page folio support in OpenAFS by modifying key components of the cache manager, particularly focusing on the VFS interface layer where the largest performance benefits can be realized. The implementation will optimize read and write paths to efficiently handle larger memory regions while maintaining backward compatibility with older kernel versions through autoconf detection and conditional compilation. By the end of the project, I will deliver: (1) A complete implementation of multi-page folio support that improves performance, especially for sequential read operations common in application deployment; (2) A comprehensive testing framework verifying functionality across multiple kernel versions; (3) Detailed performance benchmarks demonstrating throughput and resource utilization improvements; and (4) Thorough documentation of implementation details to facilitate future maintenance. All code will be submitted as incremental, well-structured patches adhering to OpenAFS coding standards.

cpythongit+4
Student: Sushil Pandey
Code

NullnessLight: A Lightweight Nullness Bug Detector for the Checker Framework

beginner
Checker Framework•2025Varies90h (Small)

I propose to develop NullnessLight, a lightweight, easy-to-use nullness checker built on the Checker Framework. NullnessLight will trade full soundness for usability and speed, helping developers catch common null-related bugs without requiring extensive annotations or setup. Inspired by tools like NullAway, NullnessLight will disable some of the more complex features of the existing Nullness Checker, such as initialization analysis and alias invalidation, and provide user-configurable options for these trade-offs. This project will broaden the Checker Framework's usability spectrum and help users gradually adopt deeper verification. Deliverables include the implementation of NullnessLight, a suite of comparisons with existing checkers (e.g., NullAway, FindBugs), and documentation with usage recommendations.

javacompilersVerification+2
Student: Abhijit Kulkarni
Code

Enhancements to pgwatch v3 RPC integration

intermediate
PostgreSQL•2025Varies175h (Medium)

The existing pgwatch3_rpc_server project creates specialized RPC endpoints that allow pgwatch3 clients to export monitoring data in various formats or redirect it to alternative data analytics & storage solutions (such as S3, ClickHouse, and others). The enhancements to be added includes the following: 1. Implementing authentication to limit access to data sinks 2. Adding TLS encryption over HTTP to secure Authentication keys and transmitted data 3. Creating templates that makes adding more sinks easier (either by the maintainers, or clients) 4. Developing additional custom sinks using the previous templates (mongodb sink, aws cloudwatch sink, azure log analytics sink, google pub/sub sink, elastic search sink, splunk sink, ...etc)

cpostgresqlperl+8
Student: ahmad gouda
Code
Proposal

Improve bootstrap

intermediate
The Rust Foundation•2025Varies175h (Medium)

This project aims to enhance the testability of Bootstrap and make it faster, the Rust build system, by improving its architecture, refining its configuration handling, and establishing a robust testing framework. It will ublock on centralizing command execution, minimizing unnecessary I/O operations and implementing testing framework. These improvements will make Bootstrap more maintainable, fast, and easier to develop and test.

pythonrust
Student: Shourya Sharma
Code
Proposal

Improving Kdenlive timeline markers

intermediate
KDE Community•2025Varies175h (Medium)

Kdenlive currently supports single-point timeline markers, which limits efficiency for workflows that require marking time ranges, such as highlight editing or collaborative annotations. This project proposes enhancing Kdenlive's marker system by introducing duration-based markers that define a clear start and end time. The project will extend the marker data model to support a duration attribute while maintaining backward compatibility. The UI will be updated to visualize range markers as colored regions on the timeline, with interactive handles for resizing and editing. These markers will be integrated with key features like zone-to-marker conversion, search and navigation, rendering specific ranges, and import/export capabilities-streamlining workflows and aligning Kdenlive with professional editing tools.

c/c++qtqml+6
Student: Ajay Chauhan 1
Code
Proposal

Improving Plugin Modernizer

intermediate
Jenkins•2025Varies175h (Medium)

Jenkins Plugin Modernizer overcomes the hurdles of manually updating and maintaining more than 2000 Jenkins plugins. Plugins contain outdated technologies or deprecated APIs, and modernization is a crucial but time-consuming process. The project aims to extract the modernization metadata (eg. did the modernization succeed, what PR it made to the plugin, etc). It helps to track the impact of the tool, the success and failure of the modernization. We aim to extract the metadata and push to a open source repo with some actions over there validating the changes. Reports will be extracted and pushed to Jenkins Report Site. The project also aims automation of finding and updating of low-scoring health plugins. More recipes will be added based on community feedback.

javascriptjavago+2
Student: Raunak Madan
Code
Proposal

Porting Puara-gestures to Avendish and creating ossia score objects

advanced
Society for Arts and Technology (SAT)•2025Varies350h (Large)

This project addresses the limited accessibility of the powerful Puara-gestures library for creating high-level gestural descriptors within modern audiovisual workflows. The goal is to bridge this gap by porting Puara-gestures to the Avendish framework, enabling its integration with the visual programming environment ossia score. This will be achieved by wrapping each Puara-gestures class in Avendish to create standardized objects that can be compiled into native ossia score processes. These objects will allow artists and designers to seamlessly incorporate sophisticated gestural analysis into interactive multimedia environments using ossia score's visual interface and timeline-based orchestration. Key deliverables include Avendish wrappers for various Puara-gestures descriptors (motion, orientation, etc.), corresponding native ossia score objects with user-friendly controls, composite objects for complex gesture recognition, comprehensive documentation and examples, and performance optimizations. Optionally, the project will explore the creation of VST/LV2 plugins for wider compatibility with Digital Audio Workstations. This integration will democratize access to advanced gestural control, benefiting artists, performers, instrument designers, and the academic research community.

pythonjavascriptopengl+4
Student: yashtiwari9182
Code

BMv2 With All Possible Output Packets

intermediate
The P4 Language Consortium•2025Varies175h (Medium)

P4 empowers developers to program the data plane of network devices—switches, routers, and NICs—at a level of detail previously only accessible to hardware designers. P4 software/simulated switches like BMv2 make the development even easier by having the programs and control plane run on developers' computers and give instant feedback. This project aims to further improve the capability of BMv2 and enable a potentially broader insight for developers to analyze their P4 program. While traditionally one packet only goes through one path within the switch and thus obtains only one result, there are many situations where it is more useful to have all possible outputs from a P4 simulation. For example, we use this for diff testing, to determine whether the switch is doing something correct or something incorrect. Multiple allowed behaviors and results usually arise from various multi-path constructs (e.g. ECMP, WCMP, or perhaps LAGs) which are often modeled as action profiles/selector in P4. BMv2 currently allows users to set a mode determining action profile/selector behavior, like `round robin` where every time one sends in the same packet, it would invoke the next possible forwarding action (eventually wrapping around). The goal of this project is to provide a new mode for BMv2 to output all possible behaviors. This will both require extending the action profile modes, and extending the notion of output from a set of packets to a set of sets of packets.

llvmc++mlir+3
Student: Xiyu Hao
Code
Proposal

Accessible-Bluff Bot

intermediate
Zendalona•2025Varies175h (Medium)

In the current accessible bluff game, users often have to wait for other players to take their turn, which can be tedious and boring. To address this, I propose developing an AI Bluff Bot that allows users to play anytime against a bot and adjust the difficulty based on their experience. The AI Mentor feature will provide real-time hints based on past moves to assist players during gameplay. All bot actions and AI Mentor features will be fully accessible, ensuring an inclusive gaming experience for all users.

pythonjavascriptandroid+2
Student: Faisal Majeed
Code
Proposal

Creating New Agent Architectures for Concordia

intermediate
Google DeepMind•2025Varies175h (Medium)

The goal of this project is to help strengthen the Concordia framework by developing and open-sourcing a collection of new language model agent architectures. The project is meant to iterate on the work done by contestants during the Concordia Contest at NeurIPS 2024. While the Concordia Contest 2024 has concluded, the need for well-documented and diverse examples of cooperative agents in the Concordia ecosystem remains important for the ongoing research in cooperative AI. The main benefit being that the new agents created will help lower the barrier of entry for new researchers and engineers, with the hope of inspiring more people to contribute unique approaches to using the framework and speed up the research being done in cooperative AI by providing practical and reusable agent implementations.

pythonjavascripttypescript+2
Student: tesims
Code
Proposal

Implement Report Builder in C++

intermediate
LibreOffice•2025Varies175h (Medium)

The Report Builder is located in LibreOffice Base, its function is to produce a report in the form of a LibreOffice Writer document from a LibreOffice Base document. As currently implemented the Report Builder uses a combination of Java and the Pentaho Report Designer library which makes maintaining its code more difficult and creates issues for packaging LibreOffice in different distributions. This project aims to solve these issues by implementing Report Builder in C++ and removing the Java and Pentaho dependencies from the LibreOffice code base.

pythonandroidjava+2
Student: Adam Seskunas
Code
Proposal
Showing 1705 - 1728 of 11996 Projects
7071727374
Proposal
Proposal
Proposal
Proposal
Proposal