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

Standardized Python Pipeline for Evaluating Perfusion Imaging Challenge

beginner
Open Science Initiative for Perfusion Imaging•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)

This project will develop a standardized Python pipeline to evaluate submissions to OSIPI perfusion imaging challenges for ASL and DSC DCE MRI methods. Researchers use different computational approaches to generate perfusion parameter maps, but there is a need for a consistent system that can validate submitted datasets run submitted code and calculate evaluation metrics in a reliable and reproducible way. The proposed pipeline will accept challenge submissions that include parameter maps and the code used to generate them. It will first validate that submitted files follow expected structures and medical imaging formats such as NIfTI and BIDS. The system will then run the submitted workflows in a controlled environment and calculate evaluation metrics such as RMSE bias and coefficient of variation. Results will be organized into reports and visualizations that allow researchers to compare the performance of different methods against reference datasets. The pipeline will be implemented in Python and designed to support both ASL and DSC DCE challenge frameworks. The architecture will focus on modular design so new datasets metrics and evaluation procedures can be added in the future. Automated testing validation checks and documentation will be included to ensure the system is reliable and easy for researchers to use and extend. This project will help improve reproducibility and transparency in perfusion imaging research by providing a clear standardized framework for benchmarking computational methods used in quantitative MRI.

pythongithub
Student: Ranya
Code
Proposal

Optimize INFORMATION_SCHEMA Queries (MDEV-31342 & MDEV-31535)

beginner
MariaDB•2026Varies90h (Small)

This project aims to resolve significant performance bottlenecks in MariaDB’s INFORMATION_SCHEMA when dealing with a high number of databases or tables. Currently, many INFORMATION_SCHEMA queries require the creation of internal temporary tables and expensive filesystem scans. The proposal focuses on two major optimizations: MDEV-31342: Implementing a mechanism to bypass temporary table creation for simple queries, allowing results to be streamed directly to the client. MDEV-31535: Optimizing the directory scanning process by leveraging the in-memory privilege cache to filter database/table visibility, thereby reducing redundant and slow I/O operations. Combined, these changes will drastically improve the responsiveness of metadata queries in large-scale MariaDB deployments.

cmysqlmariadb+7
Student: Itzanway
Code
Proposal

Payload Driven Recon Scans And New Module Workflows

intermediate
OWASP Foundation•2026Varies175h (Medium)

This project focuses on enhancing the scanning capabilities of Nettacker by introducing payload-based probing techniques for service detection. By sending protocol-aware probes instead of generic requests, the scanning engine will be able to identify running services more accurately and extract version information where possible, significantly improving reconnaissance capabilities. Overall, the proposed improvements will strengthen Nettacker's ability to perform reconnaissance scan and vulnerability discovery while expanding its coverage of vulnerabilities listed in the CISA Known Exploited Vulnerabilities (KEV) catalog and improving test coverage.

pythonjavascriptjava+10
Student: Aarush_289
Code
Proposal

Add MPCP & DPCP Support to RTEMS

intermediate
RTEMS Project•2026Varies175h (Medium)

The goal of this project is to introduce more locking protocols, in particular Multiprocessor Priority Ceiling Protocol (MPCP) and Distributed Priority Ceiling Protocol (DPCP), to RTEMS to be used by semaphores, as well as testsuites for the two protocols. This allows users to choose different locking protocols to use can be more practical depending on their application.

cpythonembedded systems+5
Student: purple-affogato
Code
Proposal

Interface the database search engine to an AI-based LLM

advanced
KDE Community•2026Varies350h (Large)

DigiKam’s Advanced Search is powerful, but translating a natural-language request into the right combination of structured filters can be difficult for many users. This project will add a natural-language input to digiKam’s Advanced Search so users can describe queries such as “landscape photos with red labels taken in Paris last summer,” which will then be converted into editable search criteria such as tags, labels, dates, and locations. The implementation will use a lightweight local language model, structured intent parsing, capability-based resolution into supported digiKam search fields, ambiguity handling for unclear terms, and caching for repeated queries, while reusing digiKam’s existing model-management infrastructure. The deliverables include the Advanced Search UI integration, the local inference and parsing pipeline, criteria resolution and validation, safe clarification behavior, and end-to-end integration with digiKam’s existing Advanced Search workflow.

c/c++qtqml+6
Student: Srirupa Datta
Code
Proposal

Multi-Protocol Support (WS, MQTT, gRPC) + CLI

advanced
API Dash•2026Varies350h (Large)

This project aims to extend API Dash by adding support for WebSocket, MQTT, and gRPC, enabling developers to work with multiple modern communication protocols within a single tool. It will introduce a modular, protocol-agnostic architecture along with intuitive UI components for real-time and streaming workflows. Additionally, a CLI will be developed to support headless usage . The focus will be on performance, usability, and seamless integration with the existing API Dash ecosystem.

flutterapiai+5
Student: Nikhil Ludder
Code
Proposal

pvlib: Standardizing Diffuse Irradiance Components and Extending ModelChain's Optical Loss Modeling

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

This project aims to improve the handling of transposed diffuse irradiance and optical loss modeling in the pvlib-python package. Currently, pvlib’s transposition models provide inconsistent output, with some providing only total sky diffuse radiation (e.g. isotropic), while others allow for outputting the isotropic, circumsolar, and horizon components. Due to this, the ModelChain workflow only allows users to define a single angle of incidence (AOI) model, and then applies the resulting incident angle modifier (IAM) to total irradiance, limiting physical accuracy. The proposed GSoC project will start by standardizing the outputs of diffuse transposition models already implemented in pvlib, introducing a consistent interface to return circumsolar, isotropic, and horizon components. Building on this, the project will extend ModelChain to support component-specific IAM calculations, enabling more accurate modeling of optical losses by distinguishing between direct and diffuse contributions. These enhancements will improve both the flexibility and accuracy of pvlib simulations while maintaining full backward compatibility. The project will include comprehensive testing and documentation to ensure reliability and ease of use.

pythonjavascriptr+3
Student: Carolina Crespo
Code

Agentic Lagrangian Extraction from the Literature ML4SCI – HEPSIM5

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

Hundreds of BSM Lagrangians have been proposed in the literature, but translating them into validated FeynRules .fr model files is still a manual, time-consuming process. This project builds an agentic system inside the HEPTAPOD framework that automates this workflow. Given a BSM scenario description, the agent searches INSPIRE and arXiv, extracts Lagrangian terms into a typed schema, generates a syntactically correct .fr file using deterministic Jinja2 templates, and validates the output through HEPTAPOD’s FeynRulesToUFOTool and a downstream MadGraph smoke test. Every literature source, extraction decision, and validation outcome is recorded in an audit trail.

pythonmachine learningc+++2
Student: kenwu
Code
Proposal

Environmental NeTworked Sensor I: Customizable dashboard, layouts, equations, export, registry.

beginner
UC OSPO•2026Varies90h (Small)

This project makes the ENTS (DirtViz) dashboard easier to grow with real field use. A lot of the UI is still wired together by hand in React, which gets painful when new sensors show up or when people want different views of the same data. The plan is to expose what can actually be plotted using live database information, mainly from the sensor table, so the app lists available sensor names, measurements, and units per cell instead of maintaining long static lists in the frontend. Power and TEROS data may still live on older storage paths for a while, so the catalog will need a clear, documented way to bridge those sources until everything lines up on one model. The headline user feature is a drag and drop dashboard: reorder panels, add or remove them, and keep layout in the URL so someone can share a view with a link. Saving layouts on the server can come later, once the client side layout behavior is solid and easy to reason about. For people comparing multiple cells, the work should also make loads feel snappier by avoiding strictly one after another requests where batching or parallel loads make sense, and by ignoring out of date responses when the selection or date range changes mid flight. After that foundation, there is room for equations for derived metrics with tight server side validation, plus CSV export of what is already on screen. Fancy per panel styling is a lower priority and might stay minimal. Overall this is steady refactoring of the existing Flask and React stack, not a from scratch rewrite, so current APIs stay stable unless an extension is clearly worth it.

pythonc/c++visualization+5
Student: Mehbub_10
Code

Proposal for B0Bot

advanced
C2SI•2026Varies350h (Large)

B0Bot is currently a monolithic Flask application relying on synchronous, manual data ingestion and a single-pass LLM pipeline to retrieve cybersecurity articles. This current architecture creates significant bottlenecks: it requires manual scripts to update knowledge bases, scales poorly under heavy loads, lacks advanced reasoning capabilities, and delivers a generic "one-size-fits-all" news feed that ignores individual user preferences and behaviors.

pythonjavago+2
Student: AQIB NAWAB
Code
Proposal

OWASP Web Application Honeypot - Adaptive Intelligence Platform

intermediate
OWASP Foundation•2026Varies350h (Large)

The OWASP Web Application Honeypot is the only open community project focused on the HTTP application layer, but it currently sits as a dormant proof-of-concept with an outdated logging format, no fingerprint detection, and no path to push threat data into community platforms like MISP. This proposal evolves it into a production-ready, adaptive, and intelligence-grade platform. The solution is built around 8 interconnected deliverables: 1. Versioned JSON logging schema (v1.0) with GeoIP2 and MITRE ATT&CK enrichment 2. Automated CRS version management via nightly GitHub Actions 3. CRS 4.x honeytrap plugin with hot-reload daemon (no container restart required) 4. Shodan Honeyscore-triggered chameleon engine for automatic persona rotation 5. Vulnerable application fingerprint library with 4 personas (Apache, IIS, phpMyAdmin, WordPress) 6. Multi-region AWS deployment framework using Terraform with centralised Kibana 7. MISP and STIX 2.1 threat intelligence exporters with optional TAXII push 8. Industry segment profiles for education, financial, and general deployments switchable via a single environment variable Each deliverable has measurable success criteria and risk mitigation. Built on prior production work in DICOMHawk, GreedyBear, and IntelOwl where identical problems were already solved. Total effort is 350 hours across 13 weeks.

pythonjavascriptjava+10
Student: R1sh0bh
Code

Query Optimization and Performance Benchmarking

advanced
omegaUp•2026Varies350h (Large)

OmegaUp has around 40 MySQL queries that do full table scans making pages slow for students and teachers. The CI pipeline detects them but never fails the build so they go unnoticed. I will optimize these queries by adding indexes and rewriting them in the DAO layer, make CI block new inefficient queries using an allowlist system, and add a performance benchmark to catch slow queries before they reach production. The goal is to make omegaUp faster today and prevent regressions in the future.

pythonmysqlphp+2
Student: mazapan
Code
Proposal

AI-Accelerated Signal Reconstruction for the ATLAS Tile Calorimeter at the HL-LHC

advanced
CERN-HSF•2026Varies350h (Large)

The ATLAS Tile Calorimeter (TileCal) currently reconstructs energy using a linear signal-processing method. For the Phase-II HL-LHC upgrade, readout will move to a 9-sample sliding window, where this approach becomes less reliable because many proton-proton collisions overlap in time. This project develops compact neural networks (MLPs and 1D-CNNs) that improve energy reconstruction while remaining small enough for real-time FPGA deployment. The approach combines a floating-point teacher CNN trained offline, knowledge distillation into a compact student model, quantization-aware training with 1-8 bit mixed precision, and magnitude pruning, targeting a strict 225 ns algorithmic latency within the 1.7 μs TilePPr budget. Deliverables include reproduced linear baselines on Phase-II simulation data, a trained teacher CNN with benchmarked energy resolution, a distilled and quantized student model, a prototype offline reconstruction integration, and a full FPGA synthesis report with latency and resource usage on a Xilinx Ultrascale+ target device.

pythonc/c++machine learning+6
Student: XBastille
Code

Add Support for Mixin Composition in Colcon Mixin

intermediate
Open Robotics•2026Varies175h (Medium)

I am C Innocent Pious, a final-year B.Tech Computer Science student from Chennai with hands-on experience in the colcon mixin codebase. Prior to this proposal, I identified and fixed a multi-year bug in multi-mixin argument merging (Issue #40, PR #59), adding six regression tests with all tests passing. This project introduces mixin composition to colcon mixin, allowing a mixin to declare dependencies on other mixins via a "mixin" key. These dependencies will be resolved automatically using a dependency graph, topological ordering, and cycle detection, eliminating the need for users to manually specify transitive dependencies in every colcon invocation. The deliverables include a dependency resolution system, cycle-safe ordering mechanism, well-defined argument merge semantics, comprehensive test coverage, and updated documentation integrated into the upstream repository.

pythonc/c++ros+5
Student: Innocent Pious
Code
Proposal

Logic Analyzer, Waveform Generation & Wireless Connectivity for PSLab-Mini

intermediate
FOSSASIA•2026Varies175h (Medium)

PSLab Mini is a compact, open source instrumentation platform built around the STM32H563 as its primary microcontroller and the ESP32-C3 as its wireless co-processor. While the board already supports oscilloscope and multimeter functionality over USB using an SCPI based interface, key features such as the logic analyzer, waveform generator and wireless connectivity remain unimplemented. This project aims to complete these missing components. A logic analyzer will be implemented using STM32 timer input capture combined with DMA driven circular buffering to enable efficient, high speed signal acquisition. Digital waveform generation will be developed using STM32 timers configured in PWM and output compare modes, supporting configurable frequency and duty cycle outputs. To enable wireless communication, a reliable STM32 to ESP32 bridge will be implemented using SPI as the primary data channel and UART as a secondary interface. A lightweight framed binary protocol will be developed to ensure robust communication between the microcontrollers. On the ESP32 side, MQTT based communication will be implemented to publish instrument data over Wi-Fi, with support for Home Assistant discovery.

pythonjavascriptandroid+7
Student: Santosh Bala
Code

Implementation of Auto-fix recipes

beginner
checkstyle•2026Varies90h (Small)

Checkstyle plays an important role in maintaining code quality in Java projects, but many of its reported violations are small, repetitive issues that developers tend to overlook. Although these problems are easy to fix, the effort required to manually locate and resolve each one discourages developers from addressing them, resulting in inconsistent code quality and growing technical debt. This project focuses on reducing that manual overhead by extending Checkstyle’s auto-fix capabilities using OpenRewrite. The main objective is to develop auto-fix recipes targeting frequently occurring Checkstyle violations. These recipes will automatically apply safe and consistent transformations to the codebase, allowing developers to resolve issues quickly and at scale. Beyond adding new recipes, the project will improve the internal design of the auto-fix system by transitioning from a position-based approach to a marker-based approach. The current method relies heavily on fixed code positions, which can become unreliable when the code structure changes. A marker-based strategy, on the other hand, enables more stable and context-aware transformations, making the system easier to maintain and extend. All implemented recipes will follow consistent design principles, include proper test coverage, and be validated on real-world open-source projects to ensure their correctness and effectiveness in practical scenarios. Overall, this project aims to streamline the process of fixing style violations, improve developer efficiency, and strengthen Checkstyle’s ecosystem by making automated code corrections more reliable and scalable.

javaantlrxpath+1
Student: Monu Chaudhary
Code
Proposal

Project 5: Helm Charts for Kubeflow Pipelines and Katib — Danish Siddiqui

intermediate
Kubeflow•2026Varies175h (Medium)

KFP and Katib users deploying via Helm currently have no upstream-supported path — charts exist but drift from Kustomize baselines silently, with no parity validation or explicit support boundaries. I've spent the last few months contributing to kubeflow/manifests (12 merged PRs) and reading through the maintainer feedback on PR #3237 closely enough to understand exactly what the constraints are. Before writing this proposal I built a PoC branch that gets all 9 scenarios (2 KFP + 7 Katib) to 0% parity diff against the upstream Kustomize baselines, traced and fixed each failure class, and ran runtime smoke tests on Kind. The goal is to upstream that work properly — charts, CI, documentation, and a support matrix that makes the supported/deferred boundary explicit. I also added two things that came out of building the PoC: a scheduled drift detection workflow and a schema validation gate using helm lint + kubeconform, both already implemented and validated.

pythontensorflowkubernetes+5
Student: danish9039
Code

Proposal - Bastien Desert "Enhance fs to examine path components"

intermediate
OpenAFS•2026Varies175h (Medium)

Users who want to understand how the AFS cache manager resolves each element of a path (plain directory, mount point, or symlink) must manually run fs examine and fs lsmount on each component separately, or write wrapper scripts. This project implements a new fs pathinfo subcommand in C that walks a given path, iteratively resolves each prefix using the existing pioctl interface (VIOC_AFS_STAT_MT_PT, VIOC_FILE_CELL_INFO, lstat), and reports the type of each component in a human-readable format consistent with existing fs output. Deliverables include: the subcommand implementation integrated into src/venus/fs.c, support for both relative and absolute paths, a -verbose flag, a fs_pathinfo(1) man page in POD format, and a regression test suite covering all major path resolution scenarios.

cpythongit+4
Student: LaLoutre
Code
Proposal

OG-CLEWS: Cross-Platform UI and Software Engineering

intermediate
United Nations Office of Information Communication Technology•2026Varies175h (Medium)

MUIOGO is an existing Flask and JavaScript application that provides a browser-based interface for running CLEWS energy-environment models. This project extends it in four directions. 1) Cross-platform hardening: fixing path assumptions, making configuration runtime-configurable, and setting up CI on macOS, Ubuntu, and Windows. 2) Building a full OG-Core UI module with parameter input forms, scenario management, run execution, and interactive Plotly results visualization, so that OG-Core has the same level of browser-based support that CLEWS currently has. 3) A coupled mode interface providing a guided workflow where one model's outputs feed into the other, with validation, multi-stage progress tracking, and combined results display. 4) A converging mode interface enabling iterative execution of both models until results stabilize, with live convergence charts, configurable tolerance, and early stopping. The project concludes with PyInstaller packaging for all three platforms, an automated GitHub Actions release pipeline, and user and developer documentation. Deliverables include a CI pipeline on three operating systems, working OG-Core standalone workflows, coupled and converging execution UIs, downloadable platform-specific installers, and complete documentation.

pythonjavascriptcss
Student: Aviral Kaintura
Code

Enhance the feature set of the Flutter Badge Magic Application

intermediate
FOSSASIA•2026Varies175h (Medium)

The objective of this project is to significantly enhance the reliability, user experience, and maintainability of the Badge Magic application. To achieve this, I will systematically resolve core Bluetooth transfer errors and animation rendering bugs, ensuring stable communication between the app and the LED hardware. Furthermore, I will streamline the user workflow by upgrading the animation preview and introducing intuitive features for managing, loading, and sharing custom designs. Finally, to secure the project's long-term health, I will integrate structured logging and error tracking for rapid debugging, alongside a fully automated CI/CD pipeline to guarantee reliable app store releases.

pythonjavascriptandroid+7
Student: ctrlVnt
Code
Proposal

Neural Network Builder API Refactor

intermediate
NumFOCUS•2026Varies175h (Medium)

The sbi (Simulation-Based Inference) library currently constructs neural density estimators via opaque factory functions that accept loose keyword arguments. This design leads to delayed validation errors crashing deep inside PyTorch rather than at configuration, tangles data preprocessing (Z-scoring) with model architecture, and prevents experiment configurations from being serialized, making reproducibility difficult for researchers. This project will refactor the neural network builder infrastructure into a modular, three-tier Layered API. By transitioning to strongly-typed Python dataclasses, the new API will introduce DensityEstimatorBuilder for fail-fast validation and a fully decoupled ZScoreConfig to isolate data standardization. This object-oriented approach ensures that invalid configurations are caught immediately and allows architectures to be easily inspected and saved.

pythonjavascriptr+3
Student: Satwik Sai Prakash Sahoo
Code
Proposal

GPU Acceleration of Plane Wave (TF/SF) Source Formulations in gprMax

advanced
gprMax•2026$6k–$13.2k350h (Large)

Problem: gprMax's devel branch GPU solver (cuda_opencl/ directory) supports CUDA, OpenCL, and Metal via shared kernel templates. But the Plane Wave (TF/SF) source from GSoC 2023 remains CPU-only Cython, forcing CPU-GPU transfers every timestep that negate GPU speedup. solution: I will create new kernel templates in cuda_opencl/ following the existing multi-backend pattern: 1) Create knl_planewave_updates.py: batched kernel updating all six 1D DPW auxiliary arrays in one launch. 2) Create knl_tfsf_injection.py: TF/SF correction injection at six boundary faces, coalescing optimized per-face with shared memory buffers. 3) Optimize boundary storage: SoA layout, 128-byte padding, precomputed index maps. 4) Testing suite: GPU vs Cython comparison across free-space, slab, oblique, and polarization cases. Why me : I built a PyCUDA heat diffusion solver with shared memory tiling, vectorized loads, and occupancy tuning, the same techniques this project needs. I have raised 8+ issues and multiple PRs to gprMax and studied all 13 files in cuda_opencl/ in depth. Deliverables: multi-backend GPU kernels for DPW update and TF/SF injection, optimized memory layout, and automated testing suite. Outcome: TF/SF runs entirely on GPU, zero CPU fallback.

pythoncythoncuda+3
Student: ABH123
Code
Proposal

Music Blocks 4 Program Builder

intermediate
Sugar Labs•2026Varies175h (Medium)

Music Blocks v4 has a modular architecture with a block editor, compiler, and execution engine built separately but not yet connected. This project integrates the Masonry visual block editor into the main application, implements block snapping and connection logic so users can build structured programs, and wires the full execution pipeline (blocks to AST to IR to output) so programs produce real music and graphics. Core deliverables: (1) Masonry module integration with palette and workspace (2) snap-based block connections with visual feedback enforcing programming semantics (3) end-to-end execution connecting blocks to the Painter and Singer modules via a real function registry. Stretch goals include inline block editing and workspace zoom/pan/undo.

pythonjavascriptgtk++10
Student: Parth Dagia
Code
Proposal

CircuitVerse Simulator Integration

intermediate
CircuitVerse.org•2026Varies175h (Medium)

This project focuses on improving the CircuitVerse simulator experience by targeting four major tasks: - Having a separate simulator-<version>.js and simulator-embed-<version>.js as separate output files. - Integrating simulator session with rails session - Implementing authentication mechanism for desktop version which is built using Tauri - Addition of the new circuit debugging suite

postgresqljavascriptbootstrap+8
Student: Supreeth C
Code
Proposal
Showing 577 - 600 of 11996 Projects
2324252627
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal