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

Ray Marching for Mesh Generation

intermediate
CGAL Project•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)

Some packages in CGAL need to compute the intersections of segments, rays, or lines with an implicit function. This is generally done through naive bisection algorithms. For some configurations however, we know that the implicit function is a signed distance field (offset meshing, alpha wrapping, ...), or an harmonic function (Poisson reconstruction). In these configurations, we can do better than bisection algorithms. The goal of this project is to implement these marching algorithms for the 3D Mesh Generation, Poisson Surface Reconstruction, and Alpha Wrapping packages, and identify other relevant packages, and possible improvements on these algorithms.

githubc++git+4
Student: Théo Tyburn
Code
Proposal

Automated Clinical Metadata Harmonization Dashboard

advanced
cBioPortal for Cancer Genomics•2026Varies350h (Large)

cBioPortal hosts 400+ cancer genomics studies whose clinical metadata is wildly heterogeneous — treatment fields alone have 24+ variants. The mentor's team built MetaHarmonizer, a 4-stage ML pipeline using sentence-transformer semantic matching and ontology resolution (NCIT, MONDO, UBERON), but it has no web interface, no audit trail, and no cBioPortal-ready export. This project wraps the pipeline in a production-ready curator dashboard: upload a raw metadata CSV, review and correct automated column mappings with confidence scores and top-5 alternatives, validate ontology term assignments, monitor quality KPIs, and export a cBioPortal-compatible TSV with a full JSON audit report. I have already built a working full-stack prototype (React + FastAPI) integrating the real SchemaMapEngine — processing 141 columns in 2.6 seconds — with 20+ REST endpoints, an on-demand LLM rematch endpoint, and an automated evaluation pipeline on the provided eval set. Deliverables: (1) production-grade backend with PostgreSQL persistence and role-based auth, (2) polished React dashboard with all needed curator pages, (3) formal ML benchmarking report, (4) CI/CD pipeline and (5) full documentation and cBioPortal deployment guide.

javascriptjavaweb+9
Student: Ahmed_Osama
Code

Refactoring in order to reduce Git’s global state

intermediate
Git•2026$3k–$6.6k175h (Medium)

Git’s core C codebase still relies heavily on global state, such as the_repository and various environment-derived variables defined in environment.c. While this design was sufficient for a standalone CLI tool, it becomes problematic in more demanding scenarios. In particular, the reliance on implicit global state makes it difficult to safely embed Git as a library. Functions may read configuration or environment variables through global state, and in some cases call die(), which terminates the entire process. This behavior is incompatible with long-running or multi-threaded applications that need finer-grained control over error handling and repository isolation. Building upon the ongoing work from previous GSoC and Outreachy efforts, this project focuses on reducing such global dependencies by making state explicit. Where appropriate, repository-specific data will be passed through struct repository and related structures such as repo_settings or repo_config_values. Subsystem-specific variables will be localized to their respective domains instead of remaining globally accessible. By replacing implicit global assumptions with explicit data structure, this work aims to make Git’s internal APIs easier to reason about, safer to use in multi-repository contexts, and more suitable for long-term libification.

cshell scriptgit+2
Student: Tian Yuchen
Code
Proposal

Graphical package manager support in templates

beginner
Qubes OS•2026Varies90h (Small)

I believe Qubes is an easy and intuitive tool to achieve “reasonable” security, as it relies on explicit compartmentalization and force users to actively think about their actions. As massive cyberattacks are growing, Qubes is increasingly becoming an essential tool for the general public, reinforcing the need for UX- focused software. This project will make Qubes more accessible for people from diverse backgrounds by providing UX-focused GUI tools for software installation in templates.

cpythonxen+3
Student: I'mSofia
Code
Proposal

Gluon: Multi-Oracle Reactor Architecture for EVM

intermediate
AOSSIE•2026Varies175h (Medium)

Gluon-EVM hardcodes Pyth into StableCoinReactor and StableCoinFactory, making it incompatible with Chainlink and OrbOracle. The roadmap requires multi-provider support with a provider-aware Reactor Creation frontend. Issue #8 and PR #10 define the right direction but nothing is merged. I propose to implement a unified oracle interface (IGluonOracle), build adapter contracts for Pyth, Chainlink, and OrbOracle that normalize price reads to WAD format, refactor the reactor and factory around those adapters, extend Gluon-EVM-WebUI with provider-aware deployment including an oracle safety profile that validates feed freshness, decimals, and asset mapping before deployment. Deliverables include the adapter architecture working on testnet with at least two providers by midterm, provider-aware WebUI and preflight validation by week 12, with hardening, documentation, and optional shadow-comparison harness through week 22.

pythonjavascriptswift+8
Student: Sachin Thankachan
Code
Proposal

Supporting Input Convex Neural Networks in MathOptAI.jl

beginner
NumFOCUS•2026$1.5k–$3.3k90h (Small)

MathOptAI.jl is a Julia package for embedding machine learning models into optimization problems built using JuMP. These embeddings work as optimization surrogates and replace the terms in the original formulations with approximations represented by the added variables and constraints. Input convex neural networks have some useful properties such as convexity that enable approximations with similar quality with much simpler embedded formulations. This GSOC project will extend MathOptAI to add support for input convex neural networks.

pythonjavascriptr+3
Student: kofgokhan
Code
Proposal

Migrate Intellij Plugins off Weberknecht Web Socket Library

intermediate
Dart•2026Varies175h (Medium)

The Dart and Flutter IntelliJ plugins rely on persistent WebSocket connections to communicate with the Dart VM Service and the Dart Tooling Daemon. The current implementation uses the Weberknecht WebSocket library, which does not properly handle WebSocket ping/pong control frames. In environments with antivirus software idle connections may be terminated, causing debugging sessions and tooling communication to disconnect unexpectedly. This project proposes migrating the WebSocket transport used by the Java VM service client to the modern WebSocket implementation available in the Java standard library. The migration will update the connection and message transport logic while preserving the existing VM service protocol. The deliverables include the new transport implementation, integration into both the Dart and Flutter IntelliJ plugins, removal of Weberknecht dependencies, and validation across common development workflows.

flutterdartprogramming-language
Student: Javad Asadi
Code
Proposal

Add sex structure to FIMS statistical-catch-at-age model

advanced
IOOS•2026Varies350h (Large)

This project extends the Fisheries Integrated Modeling System (FIMS) to support user-defined sex structure in population models. Currently, FIMS assumes a fixed 50/50 sex ratio, limiting its ability to represent sex-specific population dynamics used in stock assessment. To address this, the project introduces a partition-based framework that can enable sex-specific derived quantities (e.g. spawning biomass, landings) and population dynamics (e.g. mortality, selectivity) while minimizing computational overhead. Rather than implementing sex structure as a standalone feature, this approach supports a more general and extensible design for introducing partitions into the model. Three levels of model complexity will be developed and evaluated to balance flexibility and performance. The ultimate goal of this project is to implement an explicit two-sex model, which enables the capacity to model life-history dynamics differently between different sex groups. Benchmarking experiments will assess runtime and identify efficient configurations. Upon completion, this feature will expand the applicability of FIMS to a broader range of fisheries and stocks across the United States.

pythonocean sciencejava+3
Student: Szu-Yun
Code
Proposal

CISA 2025 SBOM Conformance and SPDX 3 Support

intermediate
The Linux Foundation•2026Varies175h (Medium)

The current SPDX conformance tools do not support the upcoming 2025 CISA SBOM minimum elements draft or the newly introduced AI and Dataset profiles in the SPDX v3 specification. This project bridges that compliance gap. The solution involves generating updated Python bindings for the SPDX Python model and implementing a dedicated, decoupled CISA 2025 compliance checker class. The core deliverables include: updated Python bindings supporting new AI profiles, a fully integrated CISA 2025 conformance checker, and a robust Pytest suite using real-world SBOMs for regression testing.

cpythonmysql+7
Student: Induwara Gunasena
Code
Proposal

Cross Platform SCM Support for Scrum Helper

intermediate
FOSSASIA•2026Varies175h (Medium)

Scrum Helper is a Chrome extension that helps developers automatically generate scrum reports from their source control activity. Today, it works exclusively with GitHub, leaving out a large portion of development teams who rely on GitLab, Gitea, or Bitbucket for their daily workflows. This project extends Scrum Helper into a true multi-platform tool. By introducing a clean plugin-based adapter architecture, each SCM platform gets its own isolated integration while the core reporting logic stays platform-agnostic. The result is a more maintainable codebase that any future contributor can extend with minimal effort. By the end of this project, developers on GitHub, GitLab, Gitea, and Bitbucket will all be able to generate automated scrum reports from a single extension, without changing how they work.

pythonjavascriptandroid+7
Student: KaungMyatShwe
Code
Proposal

GTK4 Transition Part 2: Sugar Shell

intermediate
Sugar Labs•2026Varies175h (Medium)

The Sugar Shell is the core desktop environment of Sugar and is responsible for activity launching, the Journal, the Frame, and system integration through DBus. The current Sugar Shell is built on GTK3, and several core components still depend on deprecated GTK3 APIs, which must be migrated to GTK4. This project focuses on the GTK4 migration of the Sugar Shell. The work includes replacing deprecated GTK3 APIs, migrating container and layout APIs to GTK4 equivalents, updating event handling using GTK4 event controllers, migrating styling to GTK CSS, and updating display and geometry handling using modern GTK4 display APIs. The migration will be done incrementally, component by component, starting with core components such as the Frame, Home View, Activity Launcher, Journal, Clipboard, and Control Panel. Each component will be migrated, tested in a running Sugar session, and submitted as small patches to ensure that the Sugar Shell remains stable and usable throughout the migration process. By the end of the project, the Sugar Shell will run on GTK4, core components will be migrated to GTK4 APIs, deprecated GTK3 APIs will be removed from migrated components, and migration documentation will be provided to support the remaining GTK4 transition work in the Sugar project.

pythonjavascriptgtk++10
Student: Dev10-sys
Code
Proposal

AI-Powered Drupal Recipe Generator

advanced
Drupal Association•2026Varies350h (Large)

Drupal Starshot Recipes speed up site building, but writing them requires deep technical skills. This project introduces an AI Recipe Generator that translates plain natural language requests directly into valid, installable Drupal Recipes. By leveraging the drupal/ai module, the system features Context Injection to map existing site entities and prevent configuration collisions. Furthermore, it utilizes a "Self-Healing Validation Loop" integrated with the Symfony YAML parser and the Drupal.org JSON:API to strictly validate module dependencies and eliminate LLM hallucinations. This tool lowers the technical barrier to entry, empowering non-technical users to build complex site features instantly while saving developers hours of manual debugging.

mysqljavascripthtml+2
Student: Hrishikesh Dalal
Code
Proposal

Improving the DICOMHawk Medical Honeypot: Profile-Driven Deception with Fingerprinting & Sandbox

beginner
The Honeynet Project•2026Varies90h (Small)

DICOMHawk is an open-source honeypot that emulates a vulnerable DICOM medical imaging server to attract and log unauthorized access attempts. The current v3.0 rewrite is functional at the core protocol level but presents a single fixed identity, lacks a web interface, has incomplete DIMSE handler coverage, and performs no analysis on attacker-submitted payloads. This project transforms DICOMHawk into a profile-driven deception platform. A profile system allows the honeypot to impersonate different medical imaging systems through YAML-backed configuration, controlling the DICOM identity, web-facing surface, and honeytrap behavior per deployment. An attacker-facing web extension built with Flask exposes realistic viewer interfaces and honeytrap endpoints, while browser and environment fingerprinting collects telemetry about attacker infrastructure. On the protocol side, the project completes missing DIMSE handlers (associate, release, abort) and adds DICOMweb (QIDO-RS, WADO-RS, STOW-RS) endpoints. A structured logging pipeline with session correlation ties DICOM, web, and fingerprint events together. A static-analysis sandbox quarantines and analyzes uploaded payloads without execution, shipping with starter YARA rules. Finally, Docker deployment is hardened for safer operation. Deliverables: Profile-based architecture with two starter profiles, attacker-facing web extension with per-profile templates, operator Web API, browser fingerprinting with correlation database, completed DIMSE and DICOMweb handlers, unified JSON event logging with session correlation, static-analysis sandbox with YARA support, and hardened Docker deployment.

pythonandroidmachine learning+16
Student: Vibe
Code

Extending Level 2 and Level 3 BLAS routines for linear algebra

beginner
stdlib•2026Varies90h (Small)

This project aims to resolve Issue add blas bindings and implementations for linear algebra by systematically adding the missing Level 1, 2, and 3 BLAS math routines to the @stdlib/blas/base/* namespace. To ensure speed and backward compatibility, every new routine will be split into two parts: a pure, low-level math engine and a simple, user-friendly classic API.This architectural split empowers the underlying math engine to safely handle complex, non-contiguous memory layouts and apply strict cache optimizations using explicit strides. Meanwhile, the classic API acts as a protective shield, automatically calculating the required memory offsets (e.g., negative strides) to deliver a seamless and intuitive developer experience.

cjavascriptnode.js+2
Student: Kaustubh Patange
Code
Proposal

PyTorch Deep Integration Auto Logging for Visdom

beginner
FOSSASIA•2026Varies90h (Small)

Visdom is a popular local-first visualization tool for PyTorch users, but it currently requires repetitive manual vis.line() calls for every metric such as loss, accuracy, and learning rate. This creates boilerplate code and slows down experiments. This project will solve the problem by adding deep native integration with both vanilla PyTorch and PyTorch Lightning. I will implement automatic metric detection and logging, a simple context manager and decorator for native training loops, configurable autograd hooks with throttling, learning-rate scheduler tracking, smart multi-run environment versioning, full multi-GPU and distributed support, and complete documentation with tutorial notebooks. The final deliverable will be a production-ready VisdomLogger that gives zero-config automatic logging while keeping full flexibility for advanced users. All features will come with comprehensive tests, a new PyTorch Integration Guide, and working demos.

pythonjavascriptandroid+7
Student: jayantparashar
Code
Proposal

Animated Interactive ggplots with animint2

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

animint2 is an R package that translates ggplot2 graphics into interactive animated web visualizations using D3.js and a custom JavaScript renderer (animint.js). This project implements four major improvements: (1) polygon holes via geom_polygon(aes(subgroup)) so geographic and scientific visualizations can render transparent holes correctly. (2) migrating getCommonChunk() from R to C++ via Rcpp for compile-time speedups. (3) moving scale/axis range calculation to the JavaScript renderer so axes update dynamically after showSelected filters. (4) writing tests, vignette documentation, and blog examples for all new features. Deliverables include merged PRs for each feature, renderer tests using acontext(), an updated animint2 vignette with real examples, and a public blog post documenting the summer's work.

cc++r+4
Student: Nishita-Shah1
Code
Proposal

KDE Print Manager – Completing CUPS 3.x Support and Printer Application Integration

beginner
The Linux Foundation•2026Varies90h (Small)

This project focuses on completing and refining KDE Print Manager’s transition to CUPS 3.x, ensuring full compatibility with the newer printing architecture while still supporting CUPS 2.x. Although core functionality already works, several features—particularly those related to modern, driverless printing—remain incomplete. The shift in CUPS 3.x toward IPP-based print destinations instead of permanent queues requires KDE Print Manager to better handle discovery, grouping, and display of printers such as network devices, IPP-over-USB printers, Printer Applications, and shared remote queues. The interface should clearly reflect the temporary, on-demand nature of these queues. A major aspect of the work involves improving support for Printer Applications, which are replacing traditional PPD-based drivers. The system should prioritize these modern solutions in workflows like “Add Printer,” while still allowing legacy configurations when necessary. Additionally, the user interface needs refinement to clearly distinguish between classic queues, driverless printers, and Printer Applications, and to provide easy access to external configuration tools like web interfaces. Finally, the project emphasizes strengthening test coverage, especially for newer CUPS 3.x features such as IPP destination handling and Printer Applications. By integrating comprehensive unit tests into the CI pipeline, the goal is to ensure long-term stability and reliability as the Linux printing ecosystem continues to evolve.

cpythonmysql+7
Student: Tarun Srivastava
Code

ExtX File System Improvement

beginner
KolibriOS Project Team•2026Varies90h (Small)

This project improves the file system driver of KolibriOS, specifically for extX file systems. Currently, the driver only supports 1 INCOMPAT feature fully implemented for R/W, and 2 for R. And can only guarantee reading and writing to ext2 filesystems. My primary goal is to achieve read/write support for modern ext4 file systems by implementing the remaining key INCOMPAT then RO_COMPAT features, and write support for the two currently implemented INCOMPAT features that are missing it. If time permits later, I might start in the simple action of recovery in case the file system was not safely unmounted, providing a simple foundation for future contributors (or me) to fully complete this huge and useful feature.

cassemblyasm+2
Student: Mathieu Morcos
Code
Proposal

ISSR - AI-Powered Funding Intelligence (FOA Ingestion + Semantic Tagging)

intermediate
HumanAI•2026Varies175h (Medium)

This project proposes an automated pipeline for ingesting, structuring, and semantically tagging federal Funding Opportunity Announcements (FOAs). The system aggregates opportunities from multiple sources, including the Grants.gov public API and NSF funding pages, combining API retrieval with web scraping to handle both structured and semi-structured announcements. Legacy FOA documents are processed using layout-aware PDF parsing to preserve reading order and extract key program information. The extracted records are normalised into a standardised JSON schema and enriched using a hybrid semantic tagging framework. Rule-based matching identifies ontology-aligned terms from controlled vocabularies, while sentence embeddings capture semantic relationships for more flexible tagging. The resulting structured dataset enables efficient discovery, search, and future grant-matching workflows.

pythonmachine learningc+++2
Student: Pratik Pawar
Code

Saikei Civil — Native IFC Roadway Design for Bonsai BIM

intermediate
BRL-CAD•2026Varies175h (Medium)

Saikei Civil is an initiative to bring professional roadway design capability to Bonsai/IfcOpenShell. The goal is to add tools, features, and functionality to Bonsai that will enable BIM-type modeling of roadways (and eventually other horizontal infrastructure), making use of the IFC 4.3 schema. This proposal aims to deliver the core tools for roadway design in 3 milestones: Vertical alignments (horizontal already implemented), Cross-section profiles, and Corridor generation. Once complete, Bonsai will be the first program capable of roadway model authoring natively in IFC, eliminating massive time and effort toward export processes, and will prevent large amounts of data loss from said exports.

pythonc/c++opengl+6
Student: MYoder
Code
Proposal

Add Support for C11 Annex K Bounds-Checking Functions in RTEMS

intermediate
RTEMS Project•2026Varies175h (Medium)

RTEMS currently lacks C11 Annex K bounds-checking functions (strcpy_s, memcpy_s, sprintf_s and ~45 others) which provide runtime buffer-size validation critical for safety-critical embedded systems. Without these, RTEMS developers writing software for spacecraft, medical devices, and automotive controllers are forced to use unsafe standard functions or write their own wrappers — neither is acceptable for safety-critical code. This project packages safeclib (rurban/safeclib) through the RTEMS Source Builder (RSB) so any RTEMS BSP can access these functions via -lsafec, directly strengthening memory safety across all RTEMS applications. The approach uses pkg-config for BSP-specific flag detection and librtemsdefaultconfig.a for configure-time link tests. Deliverables include a working RSB recipe, full test suite validation (~126 tests) under QEMU SPARC emulation, all ~45 Annex K functions documented in the RTEMS POSIX Compliance Guide, and a release notes entry.

cpythonembedded systems+5
Student: Yash Bhiwania
Code

Continued Development of Translation Tracker

intermediate
Processing Foundation•2026$3k–$6.6k175h (Medium)

This project is an extension of the Translation Tracker from the GSoC 2025 to support community translation of the p5.js reference documentation. I'm solving the problem and the gap in the current translation tracker infrastructure. P5.js documentation currently has five languages (English, Spanish, Simplified Chinese, Korean, and Hindi). P5.js is growing, and we need an infrastructure to support the translations. The goal is to improve/add GitHub Actions and workflows that assist human translation by volunteer translators, not to support the AI agents' translation.

pythonjavascriptandroid+6
Student: Aashish Panthi
Code
Proposal

MaterialX Shader Authoring in Blender

intermediate
Blender Foundation•2026Varies175h (Medium)

Blender currently supports exporting MaterialX within USD, but lacks meaningful support for authoring or executing MaterialX-standard shader graphs natively. This project aims to introduce the MaterialX standard node library into Blender's shader editor as first-class native nodes. A working execution prototype through Cycles' OSL backend will serve as the secondary deliverable, enabling round-trip evaluation of authored graphs during the project timeframe. Adding this feature to Blender will make it easier for 3D assets to interoperate with other DCCs, and will make Cycles a great candidate as the reference renderer for MaterialX.

cpythonopengl+3
Student: Owen O'Malley
Code
Proposal

GreedyBear: Dashboard Modularization

intermediate
The Honeynet Project•2026Varies175h (Medium)

This project aims to refactor GreedyBear's dashboard into a fully configuration-driven widget system, giving administrators the power to tailor the interface without any code changes. Currently, every widget (type, data source, size, and position) is hardcoded, making customization impossible without touching the source code. The work is organized into three layers: a Widget Registry that maps each widget to its React component, default size, and API endpoints; a Dashboard Configuration stored as a JSON blob in the backend and served via a DRF endpoint; and an Admin UI featuring drag-and-drop reordering and resizing, accessible only to superusers. All eight existing widgets will be refactored into self-contained, registry-conformant components, and a shared useWidgetData hook will eliminate duplicated data-fetching logic across the codebase. A Django DashboardConfig model will persist the global layout, with a graceful fallback to the default configuration when none exists.

pythonandroidmachine learning+16
Student: armoredvortex
Code
Proposal
Showing 913 - 936 of 11996 Projects
3738394041
Proposal
Proposal
Proposal
Proposal
Proposal