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

AI-Assisted PostgreSQL Optimization Using EXPLAIN Plans

beginner
CERN-HSF•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 →
90h (Small)

Nopayloaddb is used to serve time-sensitive conditions data for high-energy physics (HEP) experiments, so performance is critical: slow IOV lookups can delay entire reconstruction workflows. Right now, the database layer doesn’t have replicas or strong observability, even though the application already includes configuration hooks for PgBouncer and read-only database connections. In this 24-week project, I plan to improve reliability and performance by adding streaming replication, along with monitoring using Prometheus, Grafana, and Loki. I’ll also build a replica-based EXPLAIN analysis system powered by pg_stat_statements to safely study query performance. On top of that, I’ll develop a layered AI assistant (combining rules, LLMs, and parameter hints) that provides reviewed, allow-listed optimization suggestions through a simple REST API. All of this will be done without modifying existing Django schemas, and the results will be validated through benchmarking and clear documentation.

pythonc/c++machine learning+6
Student: Sarthak18
Code
Proposal

Task and TaskGroup Tracking for Swift Concurrency

advanced
Swift•2026Varies350h (Large)

Swift's concurrency runtime has no mechanism to enumerate live Tasks and TaskGroups. When a program using async/await stalls, existing tools such as thread backtraces, Instruments, LLDB are silent about the suspended tasks that are the likely cause. Instruments records task lifetimes after completion; there is no API, debugger command, or crash report field that answers "what tasks exist right now and what are they waiting on?" This project implements a global registry of live AsyncTask and TaskGroup instances inside the Swift Concurrency runtime. The core challenge is doing this without introducing unacceptable synchronisation overhead on every task creation and destruction, a hot path in any concurrent Swift program. I will implement and benchmark at minimum two candidate data structures: a sharded-mutex intrusive list (using PrivateStorage, which is opaque externally and safe to extend without breaking ABI) and a lock-free Treiber stack alternative. Deliverables: A working registry implementation with hooks in swift_task_create_commonImpl and AsyncTask::~AsyncTask() A design document comparing candidate data structures with measured overhead against the existing TaskGroups.swift and AsyncTree.swift benchmark suite Signal-safe crash backtrace integration listing live tasks on crash LLDB Python macros for interactive task inspection.

llvmc++cmake+5
Student: Ege Kaya
Code
Proposal

Using Next-Gen Transformers to Seed Generative Models for Symbolic Regression

intermediate
Machine Learning for Science (ML4SCI)•2026Varies175h (Medium)

Symbolic regression (SR) aims to discover human-interpretable mathematical expressions from numerical data. While recent transformer models achieve high token-level accuracy on physics datasets, they struggle to recover exact, functionally correct equations. Conversely, generative techniques like Genetic Programming (GP) excel at numeric fitting but explore expression space blindly. This project solves this structural gap by combining modern transformer priors with generative search. I will build upon previous ML4SCI projects to implement a hybrid pipeline: an xVal-encoded seq2seq transformer generates structurally sound candidate expressions, which seed a GP population. The GP outputs are then ranked and used to iteratively fine-tune the transformer via Direct Preference Optimization (DPO).

pythonmachine learningc+++2
Student: Dhruv1108
Code

Spatio-Temporal Dynamics of Wildfires Fairbanks in 100 miles

intermediate
Alaska•2026Varies175h (Medium)

This study focuses on the spatio-temporal dynamics of forest wildfires in Fairbanks under a changing climate. The research aims to analyze the patterns, causes, and impacts of wildfire occurrences using geospatial techniques. Satellite data such as Landsat and MODIS will be used to derive key indices including NDVI and NDMI to assess vegetation health and moisture conditions. Land Use/Land Cover (LULC), slope, aspect, wind speed, temperature, and rainfall data will be integrated within a GIS environment. Temporal analysis will be conducted to identify trends in temperature and precipitation, while change detection techniques will be applied to evaluate landscape transformations. A fire susceptibility map will be generated using a multi-criteria decision analysis approach to identify high-risk zones. The study will also examine the relationship between climate variability and wildfire frequency. The results will support early warning, risk assessment, and effective wildfire management strategies in the Fairbanks region.

pythonmysqljava+2
Student: Deep Mukherjee
Code
Proposal

Attack of the Clones: Fight Back Using Code Duplication Detection From Security Patches

intermediate
Debian•2026Varies175h (Medium)

This project aims to detect vulnerable code clones in the Debian archive by automatically extracting signatures from security patches. Using a two-signal approach that separates vulnerable patterns from fix patterns, the system generates high-specificity queries to search the entire archive via Debian CodeSearch. A verification pipeline with language-aware filtering ensures that detected clones are truly unpatched instances of the vulnerability. The project delivers a complete, scalable pipeline that integrates with Debian Security Tracker workflows and produces actionable reports, significantly reducing manual effort and improving vulnerability propagation detection across the ecosystem.

pythonjavascriptc/c+++8
Student: Gajendra Nath Soren
Code
Proposal

GIMP Extension Infrastructure and Validation System

intermediate
GNU Image Manipulation Program•2026Varies175h (Medium)

The current extension ecosystem for GIMP lacks a structured and automated infrastructure for validating, publishing, and distributing extensions. This project aims to build a scalable and security-focused extension management system by improving the gimp-extensions-web infrastructure and automating the extension lifecycle. The proposed solution introduces a GitLab-based workflow where extension submissions are validated through automated CI pipelines. Python-based validation tools will ensure compliance with metadata standards, extension structure, and security constraints. After approval, extensions will be maintained in dedicated repositories under the GNOME GitLab organization, allowing maintainers to manage releases through version control and automated packaging of .gex extension packages. Additionally, the project will implement a central metadata aggregation system that collects validated AppStream metadata from all extension repositories and generates a repository snapshot (extensions.xml.xz). This aggregated metadata will allow GIMP to efficiently browse, search, and install extensions using a single metadata source. The final deliverables include a validation framework, automated submission workflow, CI-integrated packaging system, and a metadata aggregation pipeline for the GIMP extension repository.

cGEGL
Student: blezecon
Code
Proposal

Proposal for the Unified App Registry for Cytoscape App Store

intermediate
National Resource for Network Biology (NRNB)•2026Varies175h (Medium)

Currently, the Cytoscape App Store only supports plugins for the Cytoscape Desktop App. Since a web version of Cytoscape is available, web plugins and service apps can add functionality, similar to the desktop plugins. With multiple platforms, a unified app registry would be ideal in organizing plugins and extensions, with layered filtering capabilities (e.g. platform type, app type). To solve this problem, the proposal includes an implementation plan on frontend UI changes and filtering, database migrations, an updated submission and approval flow for both web apps and service apps, and health monitoring for all apps. The first 3-4 weeks will be spent discussing final changes with mentors, with database migrations to accomodate the new platform types. The frontend will also receive changes including filtering, new tags and categories. Weeks 5 and 6 will follow a similar process for web service apps. Weeks 7-10 will consist of adjusting the submission workflow, including frontend UI changes for developers and database migrations. Health checks will also be implemented, with certain criteria to determine the health status of an app. Weeks 11-12 will consist of unit testing, including health check testing, testing new uploads, latency checks and documentation.

pythonjavascriptjava+11
Student: Kevin Zhu
Code

Gamifying Data Curation on Wikidata

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

Wikidata currently lacks a strict, universally applied method to differentiate between instances, first-order classes, and metaclasses. This structural ambiguity actively degrades the reliability of the knowledge graph's ontology. This project proposes a web-based, gamified crowdsourcing tool designed to systematically categorize Wikidata entities and clean up its class order. The platform will present users with ambiguous entities and ask them to classify the item as an "individual item," "first-order class," or "metaclass" based on available statements (e.g., P279 and P31 links). To guarantee strict data correctness, the tool will implement a multi-tiered user hierarchy (Newbies, Players, and Experts) and rely on a consensus mechanism. Edge cases and disputed classifications are automatically escalated to an expert backlog. To drive user retention and data quality, the tool will feature gamified mechanics, rewarding players with points for matching the correct consensus and offering high-value rewards for successfully overturning incorrect consensus through expert review.

javascripthtmlphp+7
Student: Egezort
Code
Proposal

#17 Project Experanto

intermediate
INCF•2026Varies175h (Medium)

Implement an ast based behavioral filter enabling queries like `(treadmill>0 and eye is not nan) & screen == video`, and expand dataset support with brainsets-style integration of IBL Brain Wide Map and Allen Neuropixels.

pythonjavac+++7
Student: Reema Hanim Hanass
Code
Proposal

Improve CycloneDX Support and Update CycloneDX Exports to Spec Version 1.7

intermediate
FOSSology•2026Varies175h (Medium)

FOSSology's CycloneDX agent targets spec 1.4 and omits license texts, copyright notices, and scanner evidence. This project upgrades it to 1.7, adds a formal evidence layer separating scanner findings from human clearing decisions, implements CycloneDX import support, and adds full PHPUnit test coverage.

linuxpostgresqlc/c+++7
Student: Krrish Biswas
Code
Proposal

Improving Effect Widgets for Kdenlive

intermediate
KDE Community•2026Varies175h (Medium)

Kdenlive's effect system has three key UI gaps: the Curves effect lacks per-channel memory forcing users to apply it multiple times, the Gradient effect only supports two fixed color stops, and the Time Remapping panel has linear-only keyframe transitions with no easing. This project will build a tabbed per-channel Curves widget with backward-compatible serialization, a standalone GradientEditorWidget with arbitrary draggable color stops, and bezier handle support on RemapView connector lines with easing presets. All widgets integrate with AssetParameterModel and MLT's filter pipeline.

c/c++qtqml+6
Student: Yash Bavadiya
Code
Proposal

Apache Mahout: Automated API Documentation Pipeline for Qumat & QDP

intermediate
Apache Software Foundation•2026Varies175h (Medium)

This project aims to implement an automated documentation workflow for the QuMat (Python) and QDP (Rust) interfaces. By using Sphinx autodoc and rustdoc, the pipeline extracts documentation directly from source code to ensure accuracy and prevent manual maintenance drift. The generated content is converted into Markdown and integrated into the project's Docusaurus website to provide a unified user experience. The proposed 12-week timeline covers API auditing, multi-language integration, and versioning based on Git tags. A functional prototype has already been developed to demonstrate technical feasibility.

pythonjavascriptjava+7
Student: Vic Wen
Code
Proposal

Integration of Combine with FCCAnalyses

advanced
CERN-HSF•2026Varies350h (Large)

The Future Circular Collider (FCC) is a flagship proposal for a next-generation post-LHC particle accelerator to be built at CERN. As the FCC project scales up its physics performance studies, automating its software infrastructure to handle complex, large-scale data is critical. FCCAnalyses is the primary framework for these FCC studies, processing physics events in EDM4hep format into ROOT histograms. To extract physical meaning from these histograms - such as calculating upper limits, discovery significances, and cross-section measurements - physicists must employ dedicated statistical tools. Currently, this requires a manual translation of the data into Combine, a popular HEP statistical framework originating in the CMS Collaboration that is built on ROOT’s RooFit and RooStats libraries. This project will package Combine inside the Key4hep software stack and build a native Python interface within FCCAnalyses that automatically generates the necessary inputs to Combine, enabling a seamless end-to-end workflow. Crucially, the interface will be designed with a modular architecture, ensuring that other statistical frameworks can be seamlessly attached in the future.

pythonc/c++machine learning+6
Student: Soumyadip Niyogi
Code
Proposal

Debuggable Installations for Spack Packages

intermediate
CERN-HSF•2026Varies175h (Medium)

Spack is a dominant HPC package manager that automates scientific software installation, widely used in the HEP community. Spack builds software in temporary staging directories and installs the resulting binaries into a final prefix; this workflow complicates debugging, as debug symbols embedded in binaries reference source paths that no longer exist after installation. This proposal aims to enable debuggable installations by preserving staged source trees in the final prefix. The initial scope targets a subset of build systems with native out-of-source support, prioritizing CMake workflows. It promotes staged sources into the installation prefix as a dedicated source tree while excluding unnecessary build artifacts, and relocates debug information by rewriting source paths embedded in DWARF debug symbols to match the installed source locations. Robustness will be validated through a structured set of test cases integrated into Spack’s pytest framework and debugging tools (GDB/LLDB), covering source preservation, symbol resolution, and relocation compatibility. Current standard debugging approaches with spack develop and spack dev-build will be compared with the new workflow. The result is a practical foundation for debuggable Spack installations that improves developer workflows in HPC environments, with a potential extension to external debug symbol distribution (e.g., debuginfod) for lightweight binaries with on-demand debugging support.

pythonc/c++machine learning+6
Student: SebastianPaucar
Code
Proposal

Enhancing Nirjas & Atarashi for Accurate, Scalable License Intelligence

advanced
FOSSology•2026Varies350h (Large)

This project will enhance FOSSology's license intelligence stack by revamping both Nirjas and Atarashi into a faster, ML-driven, and language-aware pipeline. Nirjas will move from regex-oriented parsing to a Tree-sitter architecture with language packs across 248 languages, improving comment extraction fidelity in real repositories. Atarashi will be upgraded from broad full-file matching toward retrieval-plus-classification that emphasizes high-signal fragments, because keywords matter for license intent (for example, phrases like permission grant, redistribution, warranty disclaimer, copyleft, and patent terms are often decisive). To support both components, I have already upgraded the Minerva dataset pipeline to generate train/validation/test datasets for Nirjas and Atarashi using merged inputs from ScanCode LicenseDB, FOSSology licenseRef.json endpoint, and The Stack Smol comment corpus, followed by augmentation, LLM-generated hard-negative synthesis, and near-dedup. A sample dataset for benchmarking and integration testing is ready, while the full-scale dataset build is in progress. For modeling, Nirjas will use a model2vec classifier distilled from strong sentence-transformer teachers selected using MTEB/RTEB task performance together with our internal evaluations; the same model2vec distillation path is also planned for Atarashi, with a fine-tuned quantized embedding baseline retained as a fallback depending on speed/accuracy trade-offs. The expected outcome is a production-ready path to more accurate, scalable, and maintainable license detection across diverse codebases.

linuxpostgresqlc/c+++7
Student: rycerzes
Code

Counting linear extensions with volume computation and applications in AI

advanced
GeomScale•2026Varies350h (Large)

This project will implement a new volume-based approach for approximately counting linear extensions of partially ordered sets in volesti. The core idea is to exploit the special geometry of order polytopes by designing optimized exact Hamiltonian Monte Carlo boundary oracles, rather than relying on generic polytope routines. The work will include implementing specialized HMC walks, extending them to general Gaussian settings, integrating them into volesti’s volume-estimation pipeline, and evaluating their performance against existing approximation methods. Expected deliverables include the new C++ implementation, tests, examples, documentation, and a benchmark study on representative poset families.

pythonc++r+2
Student: Ke Shih
Code
Proposal

Combining FreeCAD Assembly, Multibody Dynamics, and Finite Element Analysis

intermediate
FreeCAD•2026Varies175h (Medium)

FreeCAD is a powerful CAD software with vast capabilities supporting complete technical design pipelines beginning from modelling to FEM analysis to 3D printing. By enabling FreeCAD users to perform multibody dynamic (MbD) calculations, convert the results to FEM loads and visualise the stress and strain of an assembly in motion in a single coherent workflow, FreeCAD will be better positioned to rival commercial CAD software used by the industry today. The goal of this project is to help build that workflow by improving the combined Motion workbench so that motion-derived loads can be transferred into FEM analyses in a structured and user-friendly way. This project will focus on three main objectives. The first objective is to organise the current code into a clearer object-oriented framework. The second objective is to convert idealised MbD joint forces and torques into realistic distributed FEM loads on selected contact surfaces of real parts. The third objective is to design a user interface (UI) that allows the selection of the contact regions in FreeCAD.

pythonc++qt+2
Student: Aymi
Code

CI Testing Programs & Upstream Integration for OpenPrinting

advanced
The Linux Foundation•2026Varies350h (Large)

This project establishes a comprehensive, automated Continuous Integration (CI) and testing infrastructure across five core OpenPrinting repositories (libppd, libpappl-retrofit, libcupsfilters, cups-filters, and cups-snap). Phase 1 focuses on writing native, standalone C unit tests for libppd and libpappl-retrofit utilizing Michael Sweet’s minimalist testing paradigm to achieve robust make check coverage. Phase 2 engineers a novel "DESTDIR Staging" architecture to upstream downstream Debian/Ubuntu autopkgtests directly into GitHub Actions. This allows complex system-integration tests to execute locally on every commit without host pollution, guaranteeing legacy driver compatibility and instantly catching regressions across native and QEMU-emulated architectures

cpythonmysql+7
Student: Rohit 0209
Code

NixOS vars

intermediate
NixOS Foundation•2026Varies175h (Medium)

NixOS vars allow declaring secrets that live inside (or outside) the nix store in a declarative manner. Vars already have a WIP implementation over at https://github.com/NixOS/nixpkgs/pull/370444. The project would involve me working with Lassulus (the author of said PR) on finalizing the implementation. The long term end goal is having an upstream solution to the issues tools like sops-nix and agenix are currently solving (all while remaining agnostic to the underlying format). After speaking to Lassulus, the goals I'd be working on are: - writing a good example backend implementation - thinking about and solving some remaining architectural questions (when do the vars get generated, and how that affects the system itself) - defining a clean & clear interface for third party backend implementations Answering the above questions would require studying existing solutions (clan-core, nixos-artifacts, agenix-rekey) and picking out the best ideas from each.

gitnix
Student: prescientmoon
Code
Proposal

Improved LibreOffice-JabRef integration

intermediate
JabRef e.V.•2026Varies175h (Medium)

Nowadays, more and more researchers and students choose OpenOffice as an alternative to MS Office. JabRef already provides OpenOffice integration to support reference management, but several important limitations remain: a) JabRef does not properly support footnote citation for CSL style. b) Citations inserted by other reference management tools are not compatible with JabRef. c) Several issues regarding LibreOffice have remained unsolved for years. To address these problems, this project intend to introduce a unified citation representation and a shared global ordering component to ensure consistent behavior across in-text citations, footnotes, and bibliographies. In addition, it enables smoother switching between citation styles and improves compatibility with other reference management tools. Overall, this project will enhance the reliability and usability of JabRef's OpenOffice integration for academic writing.

javajavafxlatex+3
Student: Hancong
Code
Proposal

Enhance Usability of the eventyay Badge Creator

intermediate
FOSSASIA•2026Varies175h (Medium)

The project focuses on the eventyay Badge Creator into a reliable, production-ready badge printing system for live events. The plugin currently provides a visual layout editor, PDF generation, and basic check-in integration, but the connection between checking in an attendee and getting a badge in their hand is still fragmented and manual. There is no automated flow between a successful scan and a printed badge, no way to track or retry a failed print job, no support for pre-generating badges before peak check-in begins, and the entire badge module has no automated test coverage. This project addresses all of that. It delivers a fully automated check-in-to-print workflow where volunteers simply scan a ticket and the system handles everything else. Organizers gain the ability to configure badge printing behavior per station, manage layouts through a complete API, and pre-generate badges for all attendees before the event starts. The project closes with comprehensive test coverage across the full badge lifecycle and documentation covering both system architecture and event-day operation, making the system maintainable and ready for production use at events of any scale.

pythonjavascriptandroid+7
Student: Prayag Das
Code
Proposal

System for Nodes Displaying Gizmos to Update Their Parameters

intermediate
Graphite•2026Varies175h (Medium)

Title: Generic Gizmo System for Graphite Problem: Graphite currently has 6 separate shape-specific gizmo handlers (Circle, Star, Polygon, Arc, Grid, Spiral), each with duplicated code for hover detection, drag handling, and overlay rendering. Solution: A unified, data-driven gizmo system with three components: Registry — Declarative mapping of node parameters to gizmo types Generic Gizmos — Reusable components (Slider, Dial, Angle) that work with any compatible parameter Manager — Auto-instantiates gizmos based on registry lookup Deliverables: 3 generic gizmo types (SliderGizmo, DialGizmo, AngleGizmo) All 6 existing shapes migrated to the new system Old handlers removed, reducing code duplication Developer documentation for extending to new nodes

machine learningrustvulkan+2
Student: Ayush Amawate
Code
Proposal

Enhancing a Chatbot for Generating GraphQL and Custom Queries for Cohort Descriptions

advanced
Data for the Common Good•2026Varies350h (Large)

This project enhances an existing LLM-powered chatbot for cohort discovery in the PCDC platform, enabling users to describe patient cohorts in natural language and automatically generate accurate GraphQL or custom queries. Building on last year’s system, the project focuses on improving both usability and reliability for complex query construction. The proposed approach introduces a structured and modular architecture to improve query generation quality and system extensibility. It includes a context-aware preprocessing layer, schema-aware candidate retrieval, and a validated structured output pipeline to ensure correctness of generated queries. In addition, the chatbot will be extended into a multi-tool agent capable of handling different user intents, including general inquiry, documentation browsing, GraphQL generation and modification, and cohort-level summary and comparison. Key deliverables include: (1) an improved NL-to-GraphQL generation pipeline aligned with the PCDC data model; (2) a multi-tool interactive chatbot supporting intent routing and multi-turn interactions; (3) an evaluation framework for benchmarking query accuracy and performance; and (4) enhanced domain-aware term normalization. This project aims to provide a more robust and user-friendly interface for clinical researchers to explore cohort data efficiently.

pythonjavascriptkubernetes+2
Student: YujingDong
Code

Enhancing VCell AI Platform

intermediate
National Resource for Network Biology (NRNB)•2026Varies175h (Medium)

VCell-AI is an AI-powered platform for discovering, analyzing, and exploring biological models from the VCell database. While the platform already provides a functional chatbot interface, it requires additional capabilities to support real-world usage — including authentication, usage control, and broader integration with scientific data sources. This project aims to extend the system across these dimensions. Auth0 authentication will be integrated using the existing VCell Auth0 tenant, allowing existing VCell users to log in seamlessly. On top of this, a per-user token tracking and enforcement system will be introduced, along with an admin dashboard for managing limits. The prompt handling layer will be refactored into a centralized registry to improve consistency and reduce fragmentation. Local LLM support will be exposed as a user-facing feature. The system will also be expanded with PubMed search, complementing the already implemented BioModels DB integration. To improve usability, BNGL-based molecular visualization will be integrated. Support for SBML data will be completed, and BioPAX pathway data will be introduced as an additional source for biological knowledge. Prior to the coding period, 8 pull requests have already been raised covering API standardization, local LLM bug fixes, and BNGL visualization integration as a proof of concept, demonstrating familiarity with the codebase and commitment to the project.

pythonjavascriptjava+11
Student: Kartik Deshpande
Code
Proposal
Showing 481 - 504 of 13453 Projects
1920212223
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal