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

nicheR shiny: Interactive GUI for ellipsoid-based virtual niches

intermediate
R project for statistical computing•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)

Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.

cc++r+4
Student: Mariana Castaneda Guzman
Code
Proposal

Native SVG Import/Export for p5.js via p5.Shape System (custom Project)

intermediate
Processing Foundation•2026Varies175h (Medium)

This project aims to add native SVG import and export capabilities to p5.js through enhancements to the p5.Shape system. Currently, p5.js only supports raster exports which limits professional workflows for artists and educators who require vector outputs. The project will first extend the Shape system by adding ArcSegment and EllipseSegment primitives to enable structured geometry recording. Then an SVG export add-on will be developed using a visitor pattern to convert recorded primitives into clean SVG paths with transform support. Key deliverables include a shape recording API, SVG export via saveSVG(), basic SVG import support, documentation, and tests. This will improve interoperability of p5.js with design tools and vector workflows while maintaining backwards compatibility.

pythonjavascriptandroid+6
Student: vansh kabra
Code

MCP Server and Agent for CDLI

beginner
Cuneiform Digital Library Initiative (CDLI)•2026Varies90h (Small)

This project improves access to the CDLI database by enabling natural language queries instead of complex search forms and syntax. It allows researchers and students to explore the database more easily without needing detailed knowledge of its structure. The system consists of an MCP server that translates plain English queries into structured CDLI API calls, along with an AI-powered research workspace embedded on the CDLI website. Users can search, retrieve, and explore data through a simple chat interface, and generate structured research outputs. Key deliverables include a production-ready MCP server, an interactive research interface, a guided research paper generation workflow, and comprehensive documentation with testing support.

pythonmysqljava+8
Student: armaanngupta
Code
Proposal

Modernizing LibTorch Backend with Zero Copy and Batching

advanced
FFmpeg•2026Varies350h (Large)

Building upon the recently merged asynchronous execution infrastructure in the FFmpeg LibTorch backend, this project targets two high-impact performance improvements: a production-grade zero-copy GPU pipeline and an optional batching engine for throughput scaling. The primary objective is to reduce host-device transfer overhead, improve real-time inference efficiency, and strengthen backend reliability for practical video processing workloads. The project deliverables include implementation, validation, and documentation aligned with FFmpeg quality and integration standards.

cgitasm+3
Student: Raja Rathour
Code
Proposal

Mailman 3 Domain Administration in Postorius

intermediate
GNU Mailman•2026Varies175h (Medium)

This project implements the domain owner role in Postorius. Right now, Mailman 3 has site admins, list owners, and list moderators, but domain administration is not fully complete. This project will allow domain owners to create mailing lists only in domains they own, use list-owner features for lists in those domains, and edit settings for their domains. The work involves updating Postorius auth helpers, reusing existing decorators and mixins, updating list creation and domain edit views, making UI changes, and adding tests. Expected result: working support for domain owners to manage lists and domains they own, along with proper test coverage.

pythondjangoemail+4
Student: a-khushal
Code
Proposal

Patient Visit Summary Printing for OpenMRS O3

intermediate
OpenMRS•2026Varies175h (Medium)

OpenMRS lacks a printable visit summary, forcing patients to verbally relay medical history during referrals and care transitions. This project adds a Visit Summary PDF generator to the existing openmrs-module-patientdocuments module, reusing the proven Patient ID Sticker pipeline (DataSetEvaluator, XML Renderer, Apache FOP). The backend gathers visit-scoped clinical data (vitals, diagnoses, lab results with reference ranges, allergies, medications, visit notes) via batch queries, renders it as XML, and transforms it to PDF through XSLT. An extensible VisitSummarySectionProvider SPI allows any module (billing, appointments, pharmacy) to contribute sections without modifying the core module. Configuration uses deploy-time Initializer keys for section toggles, concept UUIDs, and page sizes (A4/A5/A6). The frontend adds a print button in the O3 visit-detail-overview-actions slot with iframe-based PDF preview and download fallback. Deliverables include the complete backend pipeline with all clinical sections, extensible SPI architecture, configurable XSLT stylesheet, REST endpoint with privilege enforcement, frontend print extension, comprehensive tests, and documentation.

javahtml5groovy+11
Student: Amrita P.
Code
Proposal

AI-Assisted PostgreSQL Optimization Using EXPLAIN Plans

beginner
CERN-HSF•2026Varies90h (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

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
Showing 385 - 408 of 11996 Projects
1516171819
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal