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

[Kvrocks] Improve the controller UI

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

Apache Kvrocks currently uses a minimalistic UI for its Controller, which limits usability and lacks advanced features. This project aims to revamp the Kvrocks Controller UI with a modern frontend stack (Next.js, Tailwind CSS) enhancing both functionality and user experience. Key deliverables include: A fully redesigned, responsive UI with clear navigation and real-time cluster visualization. Support for single sign on (SSO) authentication. Interfaces for cluster slot migration and master node failover handling. Intuitive forms and dashboards for managing instances, namespaces, and configuration. This improved UI will make it easier for developers and administrators to monitor and control Kvrocks clusters at scale, significantly enhancing the accessibility and robustness of the platform.

pythonjavascriptjava+7
Student: Agnik Misra
Code
Proposal

EOS User Story - frontend and UX

intermediate
Python Software Foundation•2022Varies175h (Medium)

The EOS User Story project is a project that supports the development and testing of other projects. I will be working on improving and adding features to the platform. I will be working on both the frontend and backend of the project. The frontend uses react.js and the backend is made in Strapi. During the program, I will migrate the services to newer versions and add some interesting features in the comment section, notification section, labels , etc. After this program user story will be ready to use by EOS and other organizations. The main objectives of my proposal are- 1. Migration to typescript 2. Migration to Strapi V4 3. Revamping the notification section 4. Making the comment section user friendly 5. Adding more UI/UX solutions 6. Removing existing bugs.

pythonmercurialjavascript+3
Student: Hrishikesh Agarwal
Code
Proposal

MDEV-37605 Converting InnoDB-Based Binary Logs to Legacy Format

advanced
MariaDB•2026Varies350h (Large)

With MDEV-34705, MariaDB introduced the ability to store binary logs inside InnoDB tablespace files ( .ibb ) instead of traditional flat sequential files. While this brings significant performance improvements, it also creates a compatibility challenge: legacy servers and tools cannot read the new format. This project will extend mariadb-binlog to read InnoDB-format binlogs and generate legacy-format binary log files as output, ensuring backward compatibility for downgrades, migrations, and third-party tooling. Deliverables - Command line option to generate Legacy Binlog file from InnoDB based Binlog - Checksum support - Unit and Integration tests - Design documentation covering architecture, usage, and known limitations

cmysqlmariadb+7
Student: Tarun Wadhwa
Code
Proposal

Extending MariaDB SQL Capabilities with Binary Bitwise Operations and JSON Membership Queries

advanced
MariaDB•2026Varies350h (Large)

This project enhances MariaDB’s SQL engine by introducing native bitwise operations for binary and bit types and implementing the JSON MEMBER OF operator. Currently, bitwise operations are limited to 64-bit integers, restricting flexibility for large binary data, and JSON membership queries require complex workarounds. The project will extend the Type_handler framework and Item expression system to support byte-wise binary operations and integrate MEMBER OF into the SQL parser and execution engine. Deliverables include a new Func_handler_bit_bin for binary operations, full implementation of Item_func_json_member_of, parser extensions, and comprehensive MTR test coverage. These improvements will increase SQL expressiveness, performance, and compatibility with modern database workloads.

cmysqlmariadb+7
Student: Mohd Jarir Noor Khan
Code

Enhanced Developer Tools and IDE Integration

intermediate
kro | Kube Resource Orchestrator•2025Varies175h (Medium)

I’m building a tool to make working with Kro YAML files easier and more efficient. This tool, called a Language Server Protocol (LSP), will help developers by giving real-time feedback, catching errors early, and suggesting code completions. It will also make code more readable with better syntax highlighting and helpful pop-ups. The LSP will support popular code editors, starting with VS Code. I’ll also include clear instructions and examples to help users get started. My goal is to make writing and managing Kro YAML files faster and less error-prone, so developers can focus on their work without getting stuck on small issues.

prometheusgolangkubernetes+2
Student: Himanshu Kumar Sharma
Code
Proposal

A Python Command Line Interface (CLI) for the CBRAIN Distributed Computing Platform

advanced
INCF•2026Varies350h (Large)

The project develops an improved Python-based CLI for the CBRAIN distributed computing platform, aiming on usability and modular design. It replaces complex command usage with interactive, prompt-based workflows, reducing reliance on memorization. The system leverages existing CBRAIN API routes and restructures the codebase into a clean, feature-based architecture. It supports user, project, file, task, and data provider management, along with advanced operations like authentication, batch processing, multi-session, data upload / download, file querying / selection and server control. Administrative tools for logs, quotas, and system monitoring are included. Overall, the project delivers a scalable, maintainable, and user-friendly CLI that enhances productivity.

pythonjavac+++7
Student: RafsanNeloy
Code

Storage integration with Google Drive and/or Dropbox

intermediate
rocket.chat•2018Varies175h (Medium)

<p>Integration with Google cloud storage is a long requested feature in Rocket.Chat. This project aims to integrate Google Drive and Dropbox storage with Rocket.Chat, thereby allowing users to authorize Rocket.Chat to access their Drive/Dropbox accounts in exchange for a bunch of features. These include (i) upload content to Drive/Dropbox accounts directly from Rocket.Chat, (ii) create Google docs, slides and spreadsheets in Rocket.Chat for enhanced real-time collaboration, (iii) browse and download Drive/Dropbox content from Rocket.Chat using GUIs that respective APIs provide, (iv) supporting features such as file preview for Drive content and finally, rigorous tests for the project implementation.</p>

javascriptwebrtcmeteor.js+18
Student: Nikhil Kaushik
Code
Proposal

BookBrainz: Import Other Open Databases

intermediate
MetaBrainz Foundation Inc•2023$3k–$6.6k175h (Medium)

BookBrainz still has a relatively small community and contains less entities than other comparable databases. Therefore we want to provide a way to import available collections of library records into the database while still ensuring that they meet BookBrainz' high data quality standards. From a previous GSoC project, the database schema already contains additional tables set up for that purpose, where the imports will await a user's approval before becoming a fully accepted entity in the database. The project will require processing very large data dumps (e.g. MARC records or JSON files) in a robust way and transforming entities from one database schema to the BookBrainz schema. Additionally the whole process should be repeatable without creating duplicate entries.

pythonjavascriptperl+8
Student: kellnerd
Code
Proposal

Custom Performance Monitors and Debugger Plugins in Godot Engine

advanced
Godot Engine•2020Varies350h (Large)

<p>This project adds support for <strong>Custom Performance Monitors</strong> and <strong>Debugger Plugins</strong> to <em>Godot</em>. Just like built-in <em>performance monitors</em>, it tracks user-defined parameters and shows them as <em>line graphs</em> in <em>Godot Editor</em>. <strong>Custom Performance Monitors</strong> cover most use cases. Some special use cases required <em>profiling</em> and <em>visualizing</em> custom data types and <strong>Debugger Plugins</strong> cover those cases. It provides an API to <em>collect</em>, <em>process</em> and <em>transfer</em> profiling data between game and editor.</p>

openglgithubc+++7
Student: Simpu
Code
Proposal

Chatty AI

intermediate
Red Hen Lab•2024Varies175h (Medium)

Red Hen Lab focuses on various aspects of linguistics and cognitive science, including Construction Grammar and FrameNet. With a voluminous collection of research publications, Red Hen Lab receives numerous inquiries from interested individuals seeking guidance. However, due to resource constraints, they are unable to respond comprehensively to all queries. To address this issue, the proposal aims to develop two open-source AI chatbots capable of engaging with users focusing on Red Hen Lab itself as well as on Construction Grammar and FrameNet. This document proposes the utilization of a transformer-based generative model augmented with Retrieval-Augmented Generation and meticulously fine-tuned on domain-specific data sourced from Red Hen Lab and FrameNet/Construction Grammar.

machine learningopencvhigh performance computing+15
Student: Rohan Kumar Singh
Code
Proposal

QuTiP Project: Integrating Auto-differentiation with QuTiP Solvers Using JAX

advanced
NumFOCUS•2024Varies350h (Large)

The project aims to seamlessly integrate JAX's jit and auto-differentiation functionalities into QuTiP, a quantum computing simulation library, enhancing its computational capabilities. Deliverables include cataloging JAX support in QuTiP functions, adding JAX functionality with clear documentation, designing interfaces for smooth integration, and creating example notebooks for practical usage. Emphasizing advanced applications and user-friendly interfaces, the project prioritizes example notebooks demonstrating quantum control optimization tasks, along with intuitive interface designs like decorator-based integration and hybrid solvers. This project not only improves QuTiP's efficiency but also serves as an educational resource, showcasing the synergy between cutting-edge quantum computing and machine learning techniques.

pythonjavascriptr+3
Student: ragarwal00
Code

MCP Apps: Interactive Genomic Visualisations for AI Clients

intermediate
cBioPortal for Cancer Genomics•2026Varies175h (Medium)

This proposal outlines a plan to extend the cBioPortal MCP server with interactive genomic visualisation applications via MCP Apps that allow AI assistants like Claude and ChatGPT to render rich, interactive UI components directly within conversations. Rather than returning raw text or static data, the MCP server will serve four self-contained visualization apps (OncoPrint, Survival Analysis, Mutation Mapper, and Study Summary) as embeddable iframes, using bidirectional JSON-RPC communication via postMessage. This transforms the way researchers interact with cancer genomics data through AI, making cBioPortal the first genomics platform to offer interactive visual exploration inside AI chat interfaces.

javascriptjavaweb+9
Student: Luke Devlin
Code
Proposal

Having Versioned Atomic Data Repositories

intermediate
TARDIS RT Collaboration•2023Varies175h (Medium)

Carsus generates an HDF file by combining data from various sources. This HDF file can be used by Tardis to generate Atomic Spectra. However, when a new version of the atomic source rolls out, there is no way of determining the changes in the datasets. The goal of this project is to create a repository integrated with CI pipelines to periodically check for changes in the upstream data sources and maintain a repository of semantic versioned datasets along with a report on the changes in each version update. The Carsus project will be updated to use the latest data source by default by checking for updates in the data repository. Additionally, a utility function will be implemented in the Carsus to support using the older version of the datasets available on the data repository by passing the dataset version number.

pythonnumbanumpy+2
Student: Shikha Rathi
Code
Proposal

Chromium - Dawn - Static Samplers

intermediate
Chromium•2024Varies175h (Medium)

This proposal aims to implement full static sampler support for Dawn, a WebGPU implementation for Chromium. A sampler is a GPU resource that defines a set of rules for the GPU on how to read images. Currently to use samplers, it has to be specified in a GPU shader, created in the application code, and then supplied to the GPU as an input. Static samplers allow developers to specify samplers inside GPU shader code and forget about them in their program code, this significantly improves their workflow. Dawn, as the future of GPU programming in the Web, it is important to improve the developer experience and simplify the workflow. The project will involve: proposing static samplers in the WebGPU specification, implementing static samplers in D3D12, and Metal, Allowing the developer to specify static samplers in shaders and through the WebGPU API.

pythonjavascriptjava+2
Student: Srijan Dhungana
Code
Proposal

Foreign Keys for Array Elements

advanced
PostgreSQL•2017Varies350h (Large)

<p>My proposal is to target the performance issue regarding the foreign keys for the array index. Any UPDATE or DELETE statement on a Primary Key table would trigger an IR constraint violation check on the Foreign Key table which can only be accomplished by a sequential search. This renders the feature unusable for large tables. I plan to make the array GIN-indexable. Since GIN-Indexes seem very reasonable since GIN is primarily used to search for element values (PK values) that appear within composite items (FK array). This would greatly decrease the computation time since we can utilize the GIN class operator “&lt;@” (included in). I found some statistics that support the GIN vs. Sequential scan, they are included in the proposal.</p>

cpostgresqlperl+8
Student: Mark Rofail
Code
Proposal

Qualified Name Lookup for swift-syntax

intermediate
Swift•2026Varies175h (Medium)

I propose reimplementing the compiler’s qualified name lookup in the Swift-only "swift-syntax" package. I will add a new API to the SwiftLexicalLookup module that accepts a declaration group, such as a type, and returns its members —commonly properties and functions. Lifting this API into the higher-level SwiftSyntax package exposes essential semantic information, enabling build tools that perform more intricate code transformations and offer more precise diagnostics. The library will find a declaration group's members through the package's SyntaxVisitor API and optionally cache results in a new SymbolTable type. I will deliver the updated SwiftLexicalLookup library with helpful docstrings and comments, extensive unit testing, and unqualified-lookup integration, along with two dedicated documentation articles.

llvmc++cmake+5
Student: Filip Sakellariou
Code
Proposal

Improve CGAL basic viewer

beginner
CGAL Project•2020Varies90h (Small)

<p>I'm currently a Ph.D. student at the University of Southern California and focused on computer graphics. This doc proposed my detailed solutions to improve CGAL basic viewer based on my own development experience in Qt-based OpenGL design including how to achieve "clipping plane", "transparent faces", "Arrangement 2 supports", and "other basic viewers". For each goal, I studied CGAL code base, proposed my solution in steps and illustrated the goal that I want to achieve with images. Moreover, I listed the Qt-OpenGL projects and related course projects that I worked on, which will definitely help me with the implementation.</p> <p>Keywords: Qt5, OpenGL, shaders, signal, slot, clipping plane, transparent faces, traits, simple basic viewers;</p>

githubc++git+4
Student: Jing Yang
Code
Proposal

Metro-MPI++

intermediate
Free and Open Source Silicon Foundation•2025Varies175h (Medium)

Modern RTL simulation is computationally expensive and often limited by single-node processing capabilities. This proposal aims to improve Metro-MPI++, a tool for distributed RTL simulation using Verilator and MPI, to better handle large-scale designs like OpenPiton. The project focuses on automating tile and interconnect detection in OpenPiton, optimizing MPI-based simulation interfaces, integrating hybrid parallelism with OpenMP, and laying the groundwork for FPGA backend support. The deliverables include a scalable partitioning framework, enhancements to the simulation runtime, example simulations demonstrating speedup, and contributions to Verilator’s partitioning features. These improvements will make RTL simulation more scalable, accessible, and efficient for open-source hardware projects.

pythonjavascriptfpga+11
Student: Kislay Arya
Code
Proposal

Mass Commands

intermediate
OpenWISP•2026Varies175h (Medium)

Mass command execution in OpenWISP is currently limited to running commands on one device at a time, making it slow and difficult to manage at scale. This project introduces a bulk execution system that allows a single command to be applied across multiple devices with centralized tracking of progress and results. It will add a parent MassCommand model to group device-level executions, use Celery for parallel asynchronous processing, and maintain aggregated status such as progress, success, and failure counts. REST API support will enable programmatic triggering and monitoring of mass commands, while a redesigned admin interface will present results in a clear, scalable format with near real-time updates and access to individual device outputs.

pythonjavascriptdjango+5
Student: Deepanshu Sahu
Code
Proposal

Multi-view Reconstruction with Witness Camera for Blender

intermediate
Blender Foundation•2016Varies175h (Medium)

<p>The estimation of camera motion plays an important role in visual effects (VFX) industry, which enables the interaction between the virtual and the reality. Currently Blender only supports solving camera motion from a single view, which sometimes does not give satisfactory solutions. In this project, I will implement a generic-purpose multi-view tracking system that incorporates witness cameras to strengthen the estimation result. This project is composed of a front-end UI integration mainly for users to specify matched marks across cameras, and back-end optimization engine that operates on the user input. This multi-view reconstruction system will increase the stability of the camera tracking solver and help artists create high-quality visual works.</p>

cpythonopengl+3
Student: tianwei37
Code
Proposal

Integration of AI-powered Chatbots for Drupal.org

intermediate
Drupal Association•2024Varies175h (Medium)

This proposal aims to enhance user experience on Drupal.org by integrating AI-powered chatbots. The project will focus on solving the problem of providing users with a more interactive and user-friendly experience while navigating the Drupal website. By integrating chatbots, users will have access to instant support, guidance, and information retrieval, improving overall engagement and satisfaction. The project will involve researching and selecting suitable AI frameworks, designing and implementing chatbot functionality, testing for compatibility and usability, and documenting the integration process. The deliverables will include the integration of AI-powered chatbots on Drupal.org, documentation for installation and customization, demonstration of chatbot functionality, and regular blog posts or articles highlighting the benefits and usage of chatbots.

mysqljavascripthtml+2
Student: Krish Gaur
Code
Proposal

Microkernel Architecture for Drop-in Plugins

intermediate
The Palisadoes Foundation•2025Varies175h (Medium)

This project introduces a microkernel-based drop-in plugin system that enables seamless integration of new features like payments, analytics, and AI tools without modifying the core API, Admin, or App codebases. A dedicated plugin manager will handle plugin discovery, activation, and updates, while predefined extension points will allow plugins to inject functionality where needed. The system will include a secure, CDN-backed plugin store with cryptographic validation, support for containerized AI/ML plugins, and ready-to-use plugins such as a payment gateway and an AI summarizer powered by Hugging Face models. This architecture will improve scalability, foster community contributions, and make Talawa more adaptable to future needs.

javascriptmongodbnode.js+5
Student: Jai Pannu
Code
Proposal

Coroutine-like interface

advanced
Ste||ar group•2022Varies350h (Large)

HPX being up to date with Std C++ Proposals, Senders/Receivers were implemented as per P2300. But they have been missing coroutine (co_await) integration and minor functionalities as described in P2300 which is likely to be accepted. Hence I propose to implement these functionalities within the Core HPX Library. Benefits: * Coroutines introduce better async code. For example, it is more readable, local variables have the same lifespan as the coroutine which means we don’t need to worry about allocation/release. * S/R algorithms can work with coroutines which they cannot as of now unless relied on futures which as mentioned are single-time use. * Adding co_await support makes the code more structured with respect to concurrency which can also be done by library abstractions of callbacks but using co_await may make it more optimized.

c++cudaopencl+10
Student: Shreyas
Code
Proposal

Demonstrating 2D Arrangements Embedded on the Sphere

intermediate
CGAL Project•2023Varies175h (Medium)

Abstract: Recently the "2D Arrangement" package of CGAL has been enhanced with the support of 2D arrangement of geodesic arcs embedded on the sphere. Demonstrating such an arrangement graphically requires rendering in three dimensions, a.k.a. 3D graphics. Implementation Plan: The project will proceed in 2 main-stages. The output of the second stage will be a stand-alone program with its source code and the corresponding documentation. First stage: Examining the 2D arrangements & 3D polyhedron demos and also Efi Fogel’s initial implementation which has its own set of dependencies. Second stage: Implementation of the 3D arrangements on the sphere program. Here, I will incrementally port Efi Fogel’s program to a stand-alone program that solely depends on CGAL and QT5.

githubc++git+4
Student: Deniz Diktas
Code
Proposal
Showing 3817 - 3840 of 4718 Projects
158159160161162
Proposal
Proposal
Proposal