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

libc: transition differing bit-width time and offset variants and deprecate bug-prone constants

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

This proposal focuses mainly on two points of the `libc` issue tracking the `1.0` release. The first of these addresses the presence of 64-bit and 32-bit wide variants of time- and file offset-related functionality for which it has been stated that only a single, 64-bit type should exist. This should also solve the concern about which of the bit-width variants should `libc` offer, as briefly discussed in the latter comments of https://github.com/rust-lang/libc/pull/5010#issuecomment-4060131422. This proposal also attempts to deprecate a set of constants which, as described in https://github.com/rust-lang/libc/issues/3131, are prone to bugs, but most importantly, require a large amount of manual effort to deprecate in whole. The goal here would be to come up with a solution that, while still manual, would allow bulk deprecation of these symbols throughout the codebase.

pythonrust
Student: Adam Martinez
Code
Proposal

Improvement of MPBioPath for Reactome Scale Perturbation Analysis

advanced
Open Genome Informatics•2026Varies350h (Large)

MP-BioPath uses rigorous mathematical programming to predict exactly how genetic mutations or drug perturbations cascade through Reactome's biological pathways. The current model needs better integration of tissue-specific realities and address the issue of artificially diluting predictive signals when multiple proteins share similar roles (entity-set dilution). AND While the Reactome team generated an expansion of these logic networks across their entire database, this massive architecture remains unvalidated at scale. This project aims to transform MP-BioPath into a scalable, context-aware predictive engine. I will architect an automated validation pipeline to stress-test the newly generated Reactome-wide logic networks, and then use this infrastructure to systematically benchmark MP-BioPath against traditional, topology-agnostic methods like Gene Set Enrichment Analysis (GSEA). I will build a transcriptomic-weighting module as the context later: by feeding real-world RNA-seq data into the optimization model, this extension will act as "live traffic updates" for the biological pathways, dynamically adjusting node weights based on actual tissue expression to resolve entity-set dilution and enable highly specific predictions.

pythonjavanodejs+9
Student: Chryseis Xinyi Liu
Code

Automated Compilation Verification Across All Concerto Code Generation Languages

intermediate
Accord Project•2026Varies175h (Medium)

Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.

javascriptreactcompiler+5
Student: Apoorv Gadiya
Code

Implement a distinct data type for JSON

intermediate
MariaDB•2026Varies175h (Medium)

MariaDB currently implements the JSON data type as an alias for LONGTEXT rather than as a distinct type, causing JSON columns to be misreported in schema introspection, client metadata, and the wire protocol. This breaks ORM frameworks such as Ruby on Rails ActiveRecord, which cannot identify the column as JSON and silently corrupts data. It also puts MariaDB out of compliance with the SQL:2016 standard. This project implements JSON as a fully distinct type in MariaDB's type system without changing storage so that JSON columns are correctly identified and reported at every layer: schema commands, the Information Schema, wire protocol metadata, and implicit validation. Deliverables include correct SHOW COLUMNS and SHOW CREATE TABLE output, accurate INFORMATION_SCHEMA reporting, proper wire protocol type codes, implicit JSON validation on write, correct JSON function return types, and a full MTR test suite covering all changes.

cmysqlmariadb+7
Student: Hadeer Ramadan
Code
Proposal

Enhancing Wikisource Bulk OCR User Controls and Feedback Modal

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

Wikisource is an online wiki-based digital library operated by the Wikimedia Foundation where volunteers transcribe old books and documents. The Bulk OCR feature allows volunteers to OCR multiple pages of a book at once instead of doing it page by page manually. However the current implementation has several critical issues that reduce productivity and cause poor quality text being saved to wiki pages. This will directly benefit thousands of Wikisource volunteers worldwide who transcribe historical documents daily making their work faster more accurate and more enjoyable

javascripthtmlphp+7
Student: Hussein mmbaga
Code
Proposal

Implementing the Maximum Weighted Matching Algorithm for pgRouting

advanced
OSGeo (Open Source Geospatial Foundation)•2026Varies350h (Large)

This project intends to implement a Maximum Weighted Matching algorithm for pgRouting within the OSGeo ecosystem, enabling efficient graph-based optimization for spatial networks. Maximum weighted matching is a fundamental problem that identifies a set of non-overlapping edges with maximum total weight, widely applicable in logistics, vehicle assignment, and supply-demand matching. The implementation will include development of a pgr_maximumWeightedMatching() function with a SQL interface and a high-performance C++ backend leveraging Boost Graph Library or optimized custom routines, integrated seamlessly with existing pgRouting structures. The project will also provide support for weighted graphs, comprehensive documentation, unit testing using pgTap, and performance benchmarking on large-scale and real-world datasets. This addition will enhance pgRouting’s analytical capabilities by introducing advanced matching functionality for transportation and network optimization while adhering to project coding standards.

pythonjavascriptc/c+++4
Student: Mayur Galhate
Code

Physics-Informed Models for Squared Amplitude Calculation

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

This project aims to advance the SYMBA framework for calculating squared scattering amplitudes in high-energy physics by incorporating physics-informed machine learning principles. While recent transformer-based approaches have shown strong performance by framing amplitude squaring as a sequence-to-sequence problem, they largely rely on syntactic patterns and do not explicitly capture the physical structure of Feynman diagrams or the semantic roles of symbolic entities. This work proposes to bridge that gap by integrating structural and physics-aware representations into the learning process. By embedding domain knowledge into model design, this project seeks to improve accuracy, generalization, and physical consistency, particularly for complex processes such as QCD where symbolic expressions grow rapidly in complexity. The outcome will contribute towards more scalable and interpretable machine learning approaches for symbolic physics computations, while providing reproducible tools and insights that can benefit the broader ML4Sci and high-energy physics communities.

pythonmachine learningc+++2
Student: Ria Khatoniar
Code

Add Debug Adapter Protocol Support to GJS

intermediate
GNOME Foundation•2026Varies175h (Medium)

GJS is a JavaScript runtime built on Firefox's SpiderMonkey JavaScript engine and the GNOME platform libraries. It allows the use of the GNOME platform libraries in JavaScript programs. GJS powers GNOME Shell, Maps, Characters, Sound Recorder and many other apps. The Debug Adapter Protocol (DAP) defines the abstract protocol used between a development tool (e.g. IDE or editor) and a debugger. DAP makes it possible to implement a generic debugger for a development tool that can communicate with different debuggers via Debug Adapters. DAP is already supported by the most prominent code editors and tools like VS Code, Zed, Emacs, etc… (https://microsoft.github.io/debug-adapter-protocol/implementors/tools/) Today, you can already debug applications and libraries written for/with Android, Node.js, Deno, C, C++, Rust, Python and more (https://microsoft.github.io/debug-adapter-protocol/implementors/adapters/). This proposal aims to make GJS applications and libraries like GNOME Shell, Maps, Decibels etc… debuggable by implementing a DAP adapter for GJS.

cpythonjavascript+4
Student: Angelo Verlain Shema
Code
Proposal

Improving Test Coverage for the TARDIS Plasma Module

beginner
TARDIS RT Collaboration•2026$1.5k–$3.3k90h (Small)

The plasma module is used to determine the ionization and excitation states of the supernova ejecta using the basic structure of the supernova (elemental abundances, densities, radiation temperature). As described in the project description in the GSOC project page, CodeCov does not accurately report coverage of the TARDIS plasma. This is because the plasma module is used as a parameter for models and simulations, and is therefore indirectly tested by the tests of the simulation and model functions. While there are parts of the plasma module that are tested directly, many aspects of the module have no easy to find direct tests. This project aims to increase the test coverage of the plasma module and make the tests of the plasma modules easy to find and read.

pythonnumbanumpy+2
Student: Rishmita Rao
Code
Proposal

A User Repository of Artifacts for Perfusion Imaging (AURA) Platform

intermediate
Open Science Initiative for Perfusion Imaging•2026Varies175h (Medium)

This project aims to transform AURA (A User Repository of Artifacts) from a survey-based collection of perfusion imaging artifacts into an interactive, searchable web platform. It will help organize and manage artifact data more effectively while allowing users to explore artifacts based on what they observe in medical images. The platform will include structured data, image galleries, and a moderated submission system to ensure quality and privacy. It will be built using a modern web stack and designed to support future expansion to additional imaging methods and integration with quality control tools.

pythongithub
Student: Md. Sahil
Code
Proposal

Improving Regression Test Coverage

intermediate
Blender Foundation•2026Varies175h (Medium)

Blender's UI regression test suite leaves most of the editor surface untested in CI, meaning regressions are caught only by manual review. This project extends the existing UI simulate testing framework with new targeted tests covering Window Manager state transitions, all practical editor/region types, menu and operator search per editor, tool/modifier/preference draw stability, and interaction-heavy flows like drag/drop, pie menus, and selection behavior. All tests integrate into the existing CI, with documentation covering how to run and extend UI regression tests within the framework.

cpythonopengl+3
Student: Yogeshgouda_Patil
Code
Proposal

Improve Disk Space Recovery for Partial Clones

intermediate
Git•2026Varies175h (Medium)

Problem: Git's "partial clone" is a lifesaver for huge repos because it lets you download only the files you actually need. But once you download a file (a "blob"), it stays on your disk forever. Currently, Git has no way to "un-fetch" these files. Over time, your "partial" clone starts looking like a massive full clone, and the only fix is to delete everything and start over. Solution: I want to build a "reverse gear" for partial clones. My project will add a safe way for Git to drop large, local files you no longer need, while keeping a "promise" that it can get them back from the server later. I’ll be focusing on three main things: Safety: Ensuring Git double-checks that the server still has the file before we delete it locally. "Promise" Contract: Updating Git’s internal records so it knows a deleted file isn't missing, just stored remotely. User Control: Adding this to git maintenance so users can easily reclaim space without being C experts. By the end of the summer, Git will have a new capability to prune local blobs safely. This includes the core C logic for identifying and removing objects, integration with the git maintenance command, and a full suite of tests to ensure no data is ever lost.

cshell scriptgit+2
Student: Siddharth Shrimali
Code
Proposal

Historic Data for pgexporter

advanced
PostgreSQL•2026Varies350h (Large)

This project will add native historical metrics storage to pgexporter, enabling users to analyze trends and long-term performance without relying on external time-series stacks. The solution introduces an optional history module, configurable via the main settings, that can store metrics in SQLite, PostgreSQL, or TimescaleDB. Deliverables include the history storage module, a REST API for querying historical data, console integration for visualizing trends, migration/export tooling, and clear documentation for setup and backend selection.

cpostgresqlperl+8
Student: Somye
Code
Proposal

Dynamic Volume Updating of Convex Polytopes via Random-Walk Sampling

intermediate
GeomScale•2026Varies175h (Medium)

This project explores the problem of estimating how the volume of a high-dimensional convex polytope changes under sequential constraint additions. In genome-scale metabolic models, this is prevalent. The feasible steady states form such a polytope, and biological interventions (gene deletions) correspond to additional linear constraints. Quantifying the resulting volume contraction provides a geometric measure of robustness and enables detection of synthetic lethality, but existing methods require recomputing volume from scratch after each update. A dynamic volume updating algorithm that estimates relative volume changes incrementally is proposed. The method introduces constraints via an annealing schedule of parallel hyperplanes and computes local volume ratios using sample reuse with selective resampling. To maintain efficiency as the polytope becomes thin or anisotropic, the approach incorporates Constrained Riemannian Hamiltonian Monte Carlo (CRHMC). Deliverables include an annealed update framework, an incremental relative volume estimator, integration into volesti with dingo interfaces, and validation on metabolic models for robustness analysis and synthetic lethality detection.

pythonc++r+2
Student: Iva Janković
Code
Proposal

DeepLense: Lens Finding for LSST Images

advanced
Machine Learning for Science (ML4SCI)•2026$6k–$13.2k350h (Large)

In GSoC 2025, I prepared a novel physics-informed Swin Transformer to classify between lens models in simulated gravitational lensing images. The model overtook its contemporaries in sparse datasets. However, the core challenge often is that models trained on perfect simulation data often fail when applied to noisy, complex, and unlabeled observational data, like the Legacy Survey of Space and Time corpus. Thus, I am proposing an application to that model, through a real-life LSST dataset. The strategy that will be used will be a hybrid of “conventional” substructure classification using vision transformers, and a masked autoencoder, as the dataset itself is largely unlabeled. This will allow us to apply the novel architecture defined in the last project into real-world unlabeled datasets like the LSST corpus. The deliverable will be a foundational model with its core being the HEAL-Swin model, having both the strengths of a a physics-informed relativistic inference, and applicability to real-world unlabeled datasets. The aim will be to deliver publishable results by the end of the program.

pythonmachine learningc+++2
Student: DhruvSrivastava
Code

Automated Scoring System for Elicited Imitation Task Responses

intermediate
HumanAI•2026Varies175h (Medium)

AutoEIT is an NLP system for automating scoring of the Elicited Imitation Task (EIT), a language proficiency assessment where participants repeat spoken sentences. The project builds an end-to-end pipeline that transcribes audio and assigns rubric-based scores (0 to 4) by comparing responses with target sentences. It combines speech processing, linguistic rules, semantic similarity, and LLM-based evaluation. The goal is to produce reliable, scalable scoring aligned with human raters.

pythonmachine learningc+++2
Student: Shreya Khanna
Code
Proposal

AI-Assisted Curation Assistant Tool for cBioPortal

beginner
cBioPortal for Cancer Genomics•2026Varies90h (Small)

This project aims to extend the existing cBioAbstractor prototype into a schema-driven formatting pipeline that assists curators in transforming heterogeneous supplemental datasets into cBioPortal-compatible formats. Currently, curation is a manual and time-consuming process due to inconsistent file structures, lack of automated schema mapping, and the need to interpret validation errors manually. This results in inefficiencies, variability, and high onboarding effort. My preliminary extension implementation suggests the feasibility of this approach by connecting existing components, introducing fuzzy column normalization, and providing a simple interface for file upload, transformation, and result inspection. Initial qualitative experiments show that the system can reconstruct correct cBioPortal formats from intentionally perturbed datasets, suggesting strong potential for reducing manual work and improving consistency.

javascriptjavaweb+9
Student: fppcng
Code

Automated Routing QA: A Regression Testing Framework for Routing & Guidance Quality in Valhalla

intermediate
OpenStreetMap•2026Varies175h (Medium)

Valhalla currently lacks a scalable way to detect routing and guidance regressions introduced by pull requests. This project builds a three-component QA system: a coverage-driven Python route generator that produces 10,000+ test routes over a static Switzerland OSM extract, exercising all costing models and routing-relevant OSM tag categories; a GitHub Actions pipeline that builds Valhalla graphs from both master and PR code, runs all routes against both, and computes geometry and instruction diffs; and a React review application - built inside valhalla/web-app, where maintainers can inspect diffs route by route, compare map geometry and turn-by-turn instructions side by side, and accept or flag changes before the baseline updates. The deliverable is a maintainer-usable, publicly deployed QA tool that makes routing drift visible and catchable at PR review time.

javascriptjavaopengl+10
Student: Sherley Sonali
Code

Simplifying Bootloader Entry for LED Badge Magic Devices

intermediate
FOSSASIA•2026Varies175h (Medium)

The Badge Magic device has a hardware constraint that makes firmware updates nearly impossible for most users after first flash. The onboard battery prevents a Power-On Reset, permanently closing the bootloader entry window after first boot. The only existing workarounds — desoldering the battery or shorting a capacitor are unsafe and unsuitable for workshops. This project implements a Stage-1 Gatekeeper that intercepts the boot sequence before any GPIO reconfiguration occurs, checks a retention SRAM location for a magic value, and jumps to the ROM bootloader if triggered. Three entry paths are provided: a USB vendor command, a button press pattern, and the existing first-boot hold — all safe, easily repeatable and requiring no hardware intervention.

pythonjavascriptandroid+7
Student: Siddarth Pai
Code
Proposal

Classbound: Exploring Boundaries for Classifiers

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

This project aims to extend the classbound R package into a general framework for exploring and comparing classification boundaries across a wide range of models and datasets. The project will develop a modular R package that supports additional classification algorithms, including user-defined methods, along with flexible data simulation utilities and support for real datasets. It will also extend functionality to high-dimensional settings using tour-based visualization techniques, allowing users to interactively explore data structure and corresponding decision boundaries. The package will be designed for extensibility and will include comprehensive documentation, examples, and a vignette. Final deliverables will include implementations of additional classifiers, enhanced simulation capabilities, high-dimensional visualization support, and complete documentation, enabling users to better understand and compare classification models through their decision boundaries.

cc++r+4
Student: Vaibhav Manihar
Code
Proposal

TensorMap

advanced
C2SI•2026Varies350h (Large)

This project transforms TensorMap into a complete neural network design studio by introducing a data driven layer registry, expanding support to 15 layer types, enabling real time training visualization, model export in industry standard formats, post training interpretability tools and automated hyperparameter tuning. The system will improve scalability, usability and developer productivity while allowing users to design, train, analyze and optimize models visually.

pythonjavago+2
Student: kartikeygupta
Code
Proposal

Optimize a VLA Model for Embodied Intelligence: OpenVINO Toolkit (Intel) Project #21

advanced
OpenVINO Toolkit•2026Varies350h (Large)

VLA models like unifolm-vla combine a vision-language backbone with a flow matching action head. On Intel iGPU, these models face two major deployment hurdles. First, structural blockers in the model code prevent successful OpenVINO conversion. Second, the iterative denoising loop requires kernel-level optimization to reach the frequencies needed for real-time robotic control. I will resolve four specific export blockers related to Python loops, random number generation, and precision handling. After achieving a successful export, I will implement kernel fusions for AdaLayerNorm and optimize Scaled Dot Product Attention to reduce latency on Arrow Lake and Panther Lake hardware. Project Deliverables: - A working OpenVINO export pipeline for unifolm-vla with all conversion blockers resolved. - Kernel-level optimizations including AdaLayerNorm fusion and SDPA pattern fixes. - A reference project featuring export scripts, quantization configurations, and latency benchmarks. - A detailed profiling report identifying bottlenecks and primitive selection via VTune.

pythonc++x86+1
Student: MDerazNasr
Code

Add KraftKit Support for Hyperlight

intermediate
Unikraft•2026Varies175h (Medium)

This project adds Hyperlight as a new VMM backend in KraftKit, enabling Unikraft unikernels to run with `kraft run --plat hyperlight`. The work will introduce platform registration and a new Hyperlight driver in the machine layer, then implement the full machine lifecycle: create, start, stop, delete, inspect, list, logs, and watch. It will start with a minimal boot path for a basic kernel, then extend to networking and storage support where possible. By the end of the project, KraftKit will have first-class Hyperlight support, and users will be able to manage Hyperlight machines through the standard CLI workflow.

cpythonxen+3
Student: Jaidev Singh
Code
Proposal

Update Payment Hub EE dependencies

beginner
The Mifos Initiative•2026$1.5k–$3.3k90h (Small)

The Mifos Payment Hub EE (PH-EE) is a massive ecosystem with about 42 Java repositories that run the open-source DPI payment infrastructure. But there’s a problem: over the years, these components have drifted apart. We have a mix of everything: Java 8 to 17, Spring Boot 2.1 to 3.2, and the old javax.* namespace. This mess makes the platform hard to maintain, full of security risks (CVEs), and prone to dependency hell where one tiny conflict can break the whole stack. My goal for this GSoC is to fix this once and for all. I will lead a systematic migration to a modern, unified baseline: Java 21, Spring Boot 3.4, Apache Camel 4, and Jakarta EE 10. To be sure that everything is perfect, the project introduces a three-level test framework: a BOM verification step (classpath purity check that fails on any javax.* artifact), WireMock + Cucumber integration tests for behavioral equivalence validation, and an end-to-end smoke test via Mifos Gazelle against a live k3s deployment. A platform BOM and a connector starter template standardize dependency governance and build configuration across all components, so the unified baseline remains enforceable after GSoC ends.

mysqljavascriptandroid+5
Student: RinalduzziGiulio
Code
Proposal
Showing 1057 - 1080 of 13453 Projects
4344454647
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal