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

Implementing Multi-page Folio Support in OpenAFS Linux Kernel Module

advanced
OpenAFS•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)

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
Proposal

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

Community detection guide with igraph

intermediate
NumFOCUS•2025Varies175h (Medium)

Community detection is one of the most commonly used network analysis techniques. It is the process of grouping nodes of a network together based on their connections, with the scope of finding clusters which are more connected internally than externally. By uncovering these communities one can gain insight into how groups interact and how the network is organized. Community detection finds use in various scientific disciplines, including biology, neuroscience, sociology, and physics. This project aims to develop a hands-on guide to community detection with python-igraph, tailored to empirical researchers who may only have limited network science experience. The guide will be delivered in the form of an interactive, executable document, and will include detailed code examples, case studies, and visual demonstrations of the main concepts of community detection. We will cover key ideas such as modularity, hierarchical clustering, consensus clustering, and overlapping communities. Additionally, we will provide brief descriptions of community detection methods and their tradeoffs, along with examples of visualization techniques.

pythonjavascriptr+3
Student: Bea Márton
Code
Proposal

Martian Climate Dashboard

intermediate
Liquid Galaxy project•2025Varies175h (Medium)

The project aims to provide real-time and historical climate data visualization from Mars on Liquid Galaxy through an engaging and interactive experience. A Flutter-based mobile app will retrieve and process atmospheric data from the Mars Climate Database (MCD), presenting it with compelling visualizations on Liquid Galaxy.

javascriptrosgis+14
Student: Mohit_Sharma
Code
Proposal

CPA-Daemon: Behavior Driven Tests

intermediate
Software and Computational Systems Lab at LMU Munich•2025Varies175h (Medium)

CPA-Daemon is a microservice (currently gRPC service) for continuous verification of C programs with CPAchecker. Clients could craft gRPC requests (with details for instructing a CPAchecker program run) sending to CPA-Daemon and receive the program-verification response. Current CPA-Daemon integration tests require large inputs that are difficult to read within code: c input programs, CPAchecker specifications, CPAchecker configurations[3]. So our goal in this project is "A running integration-test suite for CPA-Daemon based on Cucumber". With Cucumber clear "Given / When / Then" semantics in writing test, we aim to reach the same or more branch coverage than the existing integration tests. Adopt Cucumber should help us easily add more test in the future.

pythonjavascriptjava+2
Student: Wenyi Shi
Code

Structured DNS Error Support in Chromium's DNS Stack

intermediate
Chromium•2025Varies175h (Medium)

When DNS queries fail due to policy-based restrictions (e.g., BLOCKED, CENSORED, FILTERED), DNS resolvers can attach Extended DNS Error (EDE) codes along with structured JSON metadata in the response. This proposal aims to extend Chromium's DNS stack to parse and log Structured DNS Error (SDE) and Public DNS Error (PDE) content embedded in these EDE responses. The project involves extracting JSON metadata from the extra_text field for specific EDE and exposing them through the NetLog system. These improvements will provide more transparent diagnostics and support future UX enhancements. Deliverables: Full support for parsing SDE extra text and PDE, integration with Chromium's DNS resolution pipeline, NetLog exposure of parsed fields, and unit tests to ensure robust and secure behavior.

pythonjavascriptjava+2
Student: Chenhao(Calvin) Diao
Code
Proposal

Enhancing SQLancer with External Reducer Support and Hierarchical Delta Debugging

intermediate
SQLancer•2025Varies175h (Medium)

SQLancer’s current test case reduction framework faces three key limitations: (1) tight coupling between internal reducers (Delta Debugging and AST-based), limiting extensibility; (2) structural unawareness in Delta Debugging, which treats SQL inputs linearly despite their hierarchical relationships; (3) narrow applicability due to engine-specific Reproducer dependencies (only SQLite3 supported). This project addresses these issues by introducing a modular Reducer<G> interface to decouple reduction strategies (supporting tools like C-Reduce/Perses), implementing Hierarchical Delta Debugging (HDD) to group SQL statements by logical dependencies (improving efficiency from O(n²) to O(n log n)), and automating external reducer integration through dynamic script generation. Deliverables include the modular interface, HDD-preprocessed reducers, C-Reduce/Perses adapters, and comprehensive tests/documentation.

javasql
Student: Jinhui Xu
Code
Proposal

End-to-End Historical OCR Pipeline with 80%+ Accuracy

intermediate
HumanAI•2025Varies175h (Medium)

The objective of this project is to develop a robust, end-to-end OCR pipeline capable of achieving at least 80% accuracy in recognizing characters from early modern Spanish documents. The focus will be on leveraging recent advances in Handwritten Document Recognition (HDR), an emerging subfield of document analysis that integrates document layout and text recognition into a single model. By exploring both HDR-based and traditional approaches, the project aims to create a practical solution for historical document transcription as part of the RenAIssance initiative.

pythonmachine learningc+++2
Student: Yukinori Yamamoto
Code
Proposal

Tooling for running BPF GCC tests on a live kernel

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

This project addresses the lack of execution tests for the BPF backend in GCC. While GCC has many compile-time tests, the BPF backend, which generates eBPF code run by the Linux kernel, lacks runtime validation. The goal is to create a test tool that runs eBPF programs on a live kernel in a virtual environment (using QEMU), similar to the kernel's selftest infrastructure. The tool will load and execute BPF objects and report results, allowing us to catch regressions early. Next, this tool will be integrated into GCC's Dejagnu-based testing infrastructure, and a dedicated testsuite for the BPF target will be added to the GCC testsuite. This project will help ensure that compiler changes do not inadvertently generate eBPF code that the kernel verifier rejects.

cc++openmp+3
Student: PiyushRaj927
Code
Proposal

Enhancing Debian Packaging for FOSSology

intermediate
FOSSology•2025Varies175h (Medium)

This project aims to improve the Debian packaging process for FOSSology, an open-source license compliance tool. Currently, FOSSology relies on CPack for packaging, which has limitations in flexibility and Debian policy compliance. This proposal suggests transitioning to Debian's native packaging tools (dpkg, debhelper, and lintian), automating the build process, and integrating continuous integration (CI) for better package management. Deliverables include structured Debian packages, automated build scripts, CI pipelines, and detailed documentation to facilitate future maintenance. This work will make FOSSology more accessible, easier to install, and compliant with Debian standards, benefiting system administrators and developers.

linuxpostgresqlc/c+++7
Student: Ahmed-Gamal
Code
Proposal

Improving E2E QA tests

intermediate
OpenELIS Global•2025Varies175h (Medium)

The current End-to-End (E2E) test coverage for the new React frontend stands at approximately 30%, leaving critical functionalities untested. This project aims to enhance E2E test coverage to at least 80%, ensuring comprehensive validation of the entire application workflow. By identifying gaps, developing additional test cases, optimizing execution, and integrating tests into the CI/CD pipeline, this initiative will significantly improve system reliability, user experience, and overall software stability.

postgresqljavascriptjava+2
Student: Bahati308
Code
Proposal

Cargo: Build script delegation

advanced
The Rust Foundation•2025Varies350h (Large)

This project aims to overcome the limitations of the current Build Script system by allowing multiple, well-organised build scripts, that are optional and run only when required. This approach will require less auditing, will enhance the build transparency and reduce the compile-time overhead. Build scripts in Rust facilitate compiling and linking 3rd party code, such as existing C/C++ libraries, before building a package. They are immensely important for interoperability since it prevents replacing/rewriting the already existing tools that are well-optimized for their tasks. However, the current build system has certain limitations. Only one build script is allowed per package, and it must be run before building the package, often causing unnecessary computation (e.g., during unit tests). Single Large script needs extra auditing, increase compile-time, and reduce transparency for third-party build tools, especially while passing parameters. They also cannot run unit tests within themselves. This project aims to overcome the above limitations by allowing multiple, well-organized build scripts that can be run directly from the Cargo.toml. These scripts are optional and run only when required, avoiding unnecessary expensive logic. With this, only the shared build scripts will need auditing. This approach enhances build transparency, reduces compile-time overhead, and even enables unit testing of build scripts if they are treated as a dedicated package.

pythonrust
Student: Naman Garg ( namanlp )
Code
Proposal

Unification of the Eventyay System through Enext

advanced
FOSSASIA•2025Varies350h (Large)

The goal of this project (Enext) is to unify and modernize the eventyay-tickets architecture, with a next-generation modular system that integrates ticketing, talk management, and video services under a single, maintainable Django framework. The project focuses on refactoring components, introducing containerized workflows, and improving developer efficiency with consistent configurations and plugin capabilities. Key objectives include: - Unified Event Models and Architecture Refactor - Integration of Tickets, Talks, and Video Components - Plugin Standardization (Badge, Exhibitors, OutputPDF, etc.) - Enhanced CORS, Middleware, and Static File Handling - Docker and Gunicorn Deployment Setup - Performance, Logging, and Celery Worker Integration - Testing, Documentation, and Developer Experience Improvements

pythonjavascriptandroid+7
Student: Srivatsav Auswin
Code
Proposal

Machine-Readable Repository Information Query Tool

intermediate
Git•2025Varies175h (Medium)

This project introduces a new Git sub-command (currently intended to be called git repo-info) that will centralize data currently retrieved by git rev-parse in a JSON format.

cshell scriptgit+2
Student: Lucas Oshiro
Code
Proposal

Development of Advanced User Statistics Visualizations

advanced
MetaBrainz Foundation Inc•2025Varies350h (Large)

The project aims to design and implement advanced interactive visualizations for ListenBrainz using Nivo for data visualization and integrating with the existing Flask API. Apache Spark will handle efficient data processing and aggregation. These visualizations will offer granular insights into genre trends, artist diversity, and temporal listening patterns, enhancing user experience and engagement. The project will result in the development and integration of the following four interactive charts into ListenBrainz: 1. Generate Artist Listening Activity Statistics: A function to calculate the number of listens for each artist over a specified time range, mapping the data into an interactive visualization that shows the evolution of artists a user listens to over time. 2. Generate Listens by Era Statistics: A function to calculate the number of listens grouped by the year of release of each track, producing a chart that displays listens by era, enabling users to explore the distribution of their music preferences across different periods. 3. Genre-Based Listening Patterns: A dynamic visualization that tracks a user’s engagement with different genres over time, highlighting how their music preferences evolve. It will also analyze trends in genres listened to at different times of day, revealing how mood or activity influences music choices. 4. Top Listeners: A leaderboard-style visualization that tracks and highlights the top listeners sitewide. This chart will showcase the most active users and display who listens the most within their social circles, encouraging community engagement and fostering a sense of connection among users. These interactive charts will enhance the ListenBrainz user experience by providing deeper insights into listening habits and fostering a stronger sense of community.

pythonjavascriptperl+8
Student: holycow23
Code
Showing 1849 - 1872 of 13453 Projects
7677787980
Proposal
Proposal
Proposal
Proposal