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

Sugar Activity on Demand

intermediate
Sugar Labs•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)

Sugar Activity on Demand addresses a key barrier in Sugar Labs: the difficulty learners face in creating their own activities due to the need for programming knowledge. This limits access to constructionist learning, where students learn best by building meaningful projects. This project introduces an AI-assisted system that allows learners to describe an activity in natural language and receive a fully functional, installable Sugar activity. The system combines a model-agnostic LLM pipeline, a retrieval-augmented knowledge base built from real Sugar Activity source code, and an AST-based validator to ensure that generated Python code is both correct and safe. Activities are generated with proper GTK3 interfaces, toolbar integration, and Journal support, ensuring they are fully compatible with the Sugar ecosystem. Beyond generation, the project emphasizes learning through a Reflective Studio, where learners explore, understand, and modify the generated code. Using scaffolded challenges, inline annotations, and reflection prompts, the system follows the constructionist Use → Modify → Create progression, enabling learners to gradually take ownership of their creations rather than passively consuming generated output. Deliverables AI-powered activity generation pipeline (prompt → plan → code → installable bundle) RAG-based knowledge system using real Sugar Activity examples AST-based security validation and safe code generation framework Interactive Reflective Studio with guided editing, annotations, and challenges Integration into Sugar’s Home View with a seamless “Create with AI” entry point Support for iterative refinement, version history, and sharing via the Sugar Journal This project aligns with Sugar Labs’ constructionist philosophy by transforming AI from a passive generator into an active learning partner, empowering learners not just to use software, but to understand and create it.

pythonjavascriptgtk++10
Student: Ashutoshx7
Code
Proposal

Kubeflow SDK/SparkClient - Batch Jobs, Observability & Production Readiness

beginner
Kubeflow•2026Varies90h (Small)

The current Kubeflow SparkClient (KEP-107) provides a solid foundation for running interactive Spark workloads on Kubernetes, but it is still missing key capabilities required for real-world usage, such as batch job submission, consistent job lifecycle management, and production-level observability. This project focuses on extending the SparkClient to support complete, production-ready Spark workflows. The primary goal is to implement a robust submit_job() API for batch job execution using the SparkApplication CRD, supporting both script-based and function-based workloads. Alongside this, I will design a consistent set of lifecycle APIs such as job listing, status tracking, log retrieval, and cleanup, ensuring they align with existing Kubeflow SDK patterns. To improve usability in production environments, the project will also introduce observability features, including metrics collection from the Spark REST API, structured event tracking, and basic health monitoring. These additions will help users better understand job execution, debug failures, and monitor resource usage. The implementation will build on the current architecture without breaking compatibility, focusing on reliability, validation, and consistency. The final outcome will be a more complete and production-ready SparkClient that enables users to run, monitor, and manage Spark workloads on Kubernetes in a simple and consistent way.

pythontensorflowkubernetes+5
Student: Sameer_Yadav
Code

C++/C Compatibility Tool for FFIgen

intermediate
Dart•2026Varies175h (Medium)

Extend ffigen to support C++, enabling Dart developers to use C++ libraries without manual wrappers. The project simplifies integration, reduces errors, and improves productivity by automating the process and providing a seamless developer experience.

flutterdartprogramming-language
Student: Hassnaa Mohamed Ahmed
Code
Proposal

Continuous Face-Detection with Automatic Device Switching on AI PCs using OpenVINO AUTO feature

advanced
OpenVINO Toolkit•2026Varies350h (Large)

Modern AI PCs have multiple inference devices (CPU, GPU, NPU) but most applications use only one device at a time. This project aims to build a continuous face detection application that uses the OpenVINO AUTO plugin to switch between devices during runtime without stopping inference. The application will include a GUI for manual device switching and automatic load-based device recommendations. Deliverables include a working Python application, GUI, performance benchmarks, and documentation.

pythonc++x86+1
Student: Saeed Fahim
Code
Proposal

Tarunya Webiu Propsal

advanced
C2SI•2026Varies350h (Large)

WebiU currently relies on request-time GitHub API calls with in-memory caching, which limits scalability and leads to redundant API usage. This project proposes an event-driven, serverless architecture using GitHub webhooks, queue-based processing, persistent storage, and distributed caching to efficiently aggregate and serve repository data. Additionally, lightweight AI features will be introduced to generate repository summaries and improve project discoverability. The final system will significantly reduce API usage, improve performance, and enable WebiU to scale to larger repository ecosystems.

pythonjavago+2
Student: Tarunya Kesharwani
Code
Proposal

MNE Python Scaling Documentation Interactivity via JupyterLite and Interactive Plotting

intermediate
Python Software Foundation•2026Varies175h (Medium)

MNE-Python’s documentation is extensive but primarily static, requiring local installation for users to explore data. This project aims to integrate JupyterLite into the sphinx-gallery build, enabling a "Try in Browser" feature for core tutorials. Key challenges include managing large neuroimaging datasets in a WebAssembly environment and maintaining 3D interactivity (PyVista/Trame). I will deliver a production-ready CI/CD pipeline for JupyterLite builds, a prioritized set of interactive lightweight examples, and a library of ipywidgets for real-time parameter tuning (e.g., filtering, scaling) directly in the documentation.

pythonmercurialjavascript+3
Student: Natneal
Code
Proposal

Building a Comprehensive Test Suite for gprMax

intermediate
gprMax•2026Varies175h (Medium)

gprMax, an open-source FDTD electromagnetic simulator used in published research across GPR infrastructure assessment, landmine detection, archaeology, glaciology, and NASA Mars exploration (RIMFAX/Perseverance), currently lacks comprehensive automated testing. This proposal delivers a three-tier test framework: (1) unit tests covering every core Python and Cython module in isolation; (2) integration tests verifying CPU, GPU, and MPI backend consistency and HDF5 I/O correctness; and (3) physics validation tests that compare simulation outputs against known analytical solutions including plane-wave propagation, PML reflection coefficient, energy conservation, and the reciprocity theorem. All tests run automatically on Ubuntu, Windows, and macOS via GitHub Actions on every push to devel. The end-of-summer deliverable is a production-grade, CI-integrated test suite ready for merger into the main gprMax repository.

pythoncythoncuda+3
Student: Sahibjot
Code
Proposal

Build a COSMIC-based Wayland Session for Regolith

intermediate
CCExtractor Development•2026Varies175h (Medium)

Regolith's Wayland session still depends on GNOME for session startup and settings plumbing. That makes the COSMIC path awkward to install and harder to maintain. I want to build regolith-session-cosmic, an experimental Regolith session that starts through cosmic-session, runs Sway, and removes GNOME from the bootstrap path wherever the packaging and runtime audit shows it can go. The project also includes packaging the required COSMIC components through Regolith's Voulage pipeline so the session can be installed without depending on Pop!_OS repositories, finishing the remaining COSMIC-to-Sway keyboard integration in cosmolith, and validating the core session behavior: display, lock and idle, OSD, and settings persistence. The main deliverables are a bootable experimental COSMIC session for Regolith, packaged COSMIC runtime components with reproducible offline builds for the supported target distros, the remaining input integration work in cosmolith, and a documented validation matrix for the supported session path.

clinuxvideo+14
Student: Rahul tripathi
Code

AiiDA Copilot: AiiDA Natural Language Interface Using Multi-Agent AI

intermediate
NumFOCUS•2026Varies175h (Medium)

AiiDA workflows currently require manual Python scripting. This project builds a multi-agent AI system that lets scientists interact with AiiDA through natural language. Five specialized agents handle workflow submission, configuration, diagnostics, analysis, and result queries, connected to AiiDA's Python API via MCP tools. A Validator layer prevents hallucinated parameters from reaching the compute layer. RAG-based retrieval grounds agents in AiiDA documentation. Deliverables: working multi-agent system, MCP server with 5 core tools, RAG pipeline, and architecture documentation.

pythonjavascriptr+3
Student: Jaweria Batool
Code
Proposal

#40: QC-Studio-integrated quality control toolkit for MRI datasets

intermediate
INCF•2026Varies175h (Medium)

MRI quality control (QC) is an essential but highly manual and repetitive process in neuroimaging research. Currently, reviewers must navigate scattered directories and mentally integrate diverse outputs, such as 3D volumes, SVG montages, and isolated metrics, to make a reliable assessment. This "hidden labor" takes significant time away from actual research, introduces variability across different raters, and results in decisions that are poorly documented and difficult to audit. This project aims to transform QC-Studio from a working prototype into a robust, Nipoppy-integrated application. The core of the solution focuses on replacing hardcoded file paths with a scalable, config-driven architecture utilizing Nipoppy's DatasetLayout API. Additionally, the project will inject essential quantitative context into the review process by building an Image Quality Metric (IQM) distribution panel. Finally, it will establish a structured "Evidence Bundle" to experimentally evaluate whether a lightweight LLM-based assistant can improve review efficiency by summarizing quantitative data and flagging anomalies. Key Deliverables: 1) Config-Driven Architecture: A unified Streamlit application featuring dynamic subject loading, unified pagination, and manifest.tsv integration across multiple processing pipelines without hardcoded paths. 2) Quantitative Evidence Layer: An interactive IQM panel that visualizes subject-level metrics against local datasets and crowdsourced reference distributions (MRIQC Web API), complete with rule-based outlier detection. 3) Experimental AI Guidance Prototype: A foundational integration displaying pre-generated, LLM-authored summary reports within the dashboard, accompanied by an evaluation report assessing factual accuracy and workflow impact.

pythonjavac+++7
Student: Niusha Sadat Mirhakimi
Code
Proposal

Rocket.Chat: Code Analyzer Agentic Inference Context Reduction Mechanics

intermediate
rocket.chat•2026Varies175h (Medium)

Analyzing massive codebases like Rocket.Chat via iterative LLM agents causes context bloat, rapidly exceeding free-tier limits. This project builds a graph-native code navigator exposed as a Gemini MCP server. An offline indexer parses the full Rocket.Chat source via ts-morph, extracts a typed dependency graph (11 edge kinds, including Rocket.Chat-specific patterns like callbacks.run/add and Meteor method dispatch that break standard import analysis), and compresses function bodies into signature-only skeletons for ~4× token reduction. At query time, three composable MCP tools—search, graph, implement—let an LLM navigate by following real edges rather than ranking documents. An evaluation framework with ground-truth test cases (collected by Rocket.Chat experts and Claude) and 5 measured metrics closes the loop.

javascriptwebrtcmeteor.js+18
Student: Echo Xiao
Code

Debian-LSP: Improve File Format Support

beginner
Debian•2026Varies90h (Small)

The Debian LSP Language Server currently provides only basic features — field completion, parse-error diagnostics, and simple quick fixes — leaving Debian maintainers without the rich IDE experience available in other ecosystems. This project significantly expands its capabilities across five areas identified from direct codebase exploration: clickable links and URL navigation in packaging files, richer hover documentation sourced from Debian Policy, improved completion quality with context-aware and deduplicated suggestions, consistent editor integration (with a focus on Helix), and formatting and structural editing support including folding ranges and auto-formatting. Each area will be delivered as an independent, tested pull request. The work integrates with debian-analyzer and the deb822-lossless crate to support multiple Debian control-file formats (debian/control, debian/copyright, debian/changelog, debian/watch ...) and lays the groundwork for real-time validation and go-to-definition across multi-file packaging trees.

pythonjavascriptc/c+++8
Student: Lucas Ly Ba
Code
Proposal

Dynamic LLM Trainer Framework for Kubeflow — TRL Backend with Pluggable Multi-Framework Support

intermediate
Kubeflow•2026Varies175h (Medium)

Kubeflow Trainer V2 currently supports only TorchTune as its LLM fine-tuning backend. TorchTune stopped adding new features in July 2025, leaving Kubeflow with ~4 supported models and no support for DPO, GRPO, or other post-training methods. This project builds a pluggable multi-backend framework for Kubeflow Trainer. The first new backend is TRL (HuggingFace's fine-tuning library), adding support for SFT, DPO, GRPO, Unsloth acceleration, and multi-node DeepSpeed. The architecture includes: an LLMBackend ABC + registry in the Python SDK for config-driven backend dispatch, a LLMFrameworkHandler interface in the Go control plane (Torch plugin) for zero-touch extensibility, and entry_points-based registration so the community can add backends like LlamaFactory without upstream changes. Deliverables: TRL backend (Python SDK + Go handler), pluggable registry, runtime configs, integration tests, and documentation. All existing TorchTune workflows remain unchanged.

pythontensorflowkubernetes+5
Student: Yassin Hashem
Code

BMv2 packet trace support

intermediate
The P4 Language Consortium•2026Varies175h (Medium)

BMv2 currently provides only textual logs for tracing packets through a P4 pipeline, which must be parsed with brittle regex hacks and cannot be easily consumed by automated tools. This project aims to replace that with a structured, programmatic trace API — recording per-packet events such as applied tables, matched entries, and executed actions — and exposing them in a machine-readable format such as protobuf (with JSON serialization support), enabling use cases ranging from human debugging to automated test coverage measurement, test generation, and root cause analysis.

llvmc++mlir+3
Student: c8ef
Code
Proposal

MDEV-37605 Converting InnoDB-Based Binary Logs to Legacy Format

advanced
MariaDB•2026Varies350h (Large)

With MDEV-34705, MariaDB introduced the ability to store binary logs inside InnoDB tablespace files ( .ibb ) instead of traditional flat sequential files. While this brings significant performance improvements, it also creates a compatibility challenge: legacy servers and tools cannot read the new format. This project will extend mariadb-binlog to read InnoDB-format binlogs and generate legacy-format binary log files as output, ensuring backward compatibility for downgrades, migrations, and third-party tooling. Deliverables - Command line option to generate Legacy Binlog file from InnoDB based Binlog - Checksum support - Unit and Integration tests - Design documentation covering architecture, usage, and known limitations

cmysqlmariadb+7
Student: Tarun Wadhwa
Code
Proposal

Integrating Distributional Copula Regression into the gamboostLSS Package

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

This project is about extending the gamboostLSS package by flexible copula regression via gradient boosting. Currently the framework only supports univariate responses, but there is a need to model two correlated outcomes with arbitrary marginal distributions (continuous, discrete, binary or mixed) and their dependence structure modelled through the copula. At the core of this project stands the CopulaFamilies() constructor that combines any two existing gamboostLSS family objects with a copula of the user's choice (Gaussian, Clayton, Gumbel or Frank). The constructor automatically detects the marginal types of the input and computes the appropriate joint log-likelihood, as well as the gradients via chain rule. This computation and its results integrate seamlessly into the already existing interface of gamboostLSS(), extending the cvrisk() for multi-dimensional tuning of the stopping hyperparameter and adding a transformation of the dependence parameter to the Kendall's Tau measure for summary() and plot() to establish interpretable dependence estimates. The deliverables for this project include the CopulaFamilies() constructor with automatic full marginal type detection, gradient stabilization for a method of choice (MAD, L2), model selection on the basis of predictive risk minimization, a predict() method for the evaluation of joint cumulative distribution functions and a vignette to demonstrate the full workflow on a real dataset.

cc++r+4
Student: Bjarne Herbst
Code

Enhancing SymPy’s Integral Module: Rationalizing Substitutions and Contour Integration

intermediate
SymPy•2026Varies175h (Medium)

The goal of this project is to improve the capabilities of the current integration module of SymPy. To do so, as a first step, rationalizing substitutions will be added, in order to find the antiderivative for functions that SymPy cannot handle. Subsequently, new rules for the handling of special functions will be introduced and the pre-existing code will be improved, which sometimes can report incorrect results for some edge cases. Finally, a module for contour integration will be implemented, in order to be able to calculate specific definite integrals without having to find the antiderivative, handling new cases not yet covered.

pythonc++numpy+1
Student: Edoardo Matachione
Code
Proposal

End-to-End ARM64 Support & Validation on Kubeflow

intermediate
Kubeflow•2026Varies175h (Medium)

ARM64 is becoming increasingly common with the rise of Apple Silicon and cloud instances like AWS Graviton, but Kubeflow still doesn’t run consistently on ARM-based systems. Right now, different components behave differently — some work partially, some require manual fixes, and others don’t work at all. This makes it difficult to use Kubeflow reliably outside of traditional x86 environments . The goal of this project is to make ARM64 a properly supported architecture across the Kubeflow ecosystem. Instead of partial or experimental support, the idea is to make sure Kubeflow works the same way on ARM as it does on AMD64. To achieve this, I plan to start by auditing the container images used in Kubeflow and identifying gaps in ARM64 support. Based on that, I will enable multi-architecture builds using Docker Buildx and integrate them into existing CI/CD pipelines so that ARM64 images are built and published automatically. I will also update manifests to remove architecture-specific references and ensure they work across both architectures without requiring changes. A major part of the work will be validation. I will deploy Kubeflow on ARM-based environments (OCI Ampere) and run end-to-end tests to catch issues that only appear at runtime. Any failures related to dependencies, builds, or configuration will be debugged and fixed incrementally. By the end of the project, Kubeflow should be able to run end-to-end on ARM systems without manual workarounds. The final output will include working multi-architecture builds, improved CI/CD pipelines, updated manifests, and a clear “golden setup” guide for running Kubeflow on ARM. Overall, this project is about making Kubeflow more consistent and usable across modern infrastructure, especially as ARM adoption continues to grow.

pythontensorflowkubernetes+5
Student: Syed Mohd Maaz
Code
Proposal

Enhanced Interaction and Navigation in JSON Schema Studio

advanced
JSON Schema•2026Varies350h (Large)

JSON Schema Studio visualizes JSON Schemas as interactive graphs, helping developers understand complex structures. While the current version works well, there are areas where rendering correctness and user experience can be improved. This project focuses on ensuring correct dependency-based rendering (especially for $defs), improving graph navigation, and enhancing synchronization between the editor and visualization. It will also address issues like edge collisions and unstable rendering during live edits. Additionally, features like validation error navigation, file upload, and visualization export will be introduced to improve usability. The final deliverables include: - Dependency-aware rendering using topological sorting - Improved graph interaction and navigation - Validation error navigation in the editor - Reduced edge collisions - Stable rendering during live edits - File upload and export support These improvements will make the tool more accurate, interactive, and useful for developers.

pythonjavascripttypescript+2
Student: Sumit goyal
Code
Proposal

FOSSASIA WordPress Platform: Eventyay Integration, Membership System, and Email Infrastructure

advanced
FOSSASIA•2026Varies350h (Large)

This project aims to modernize the FOSSASIA WordPress platform by upgrading outdated components and aligning the system with current web standards. It mainly focuses on enhancing the Eventyay integration to support the latest APIs and provide richer event features such as ticketing, exhibitions, and detailed event content. The project also replaces external newsletter tools with a cost-efficient, WordPress-native email system, while introducing a scalable membership framework for contributors, organizations, and partners. Additionally, it includes donation functionality and frontend improvements to ensure better performance, responsiveness, and user experience. Overall, the goal is to deliver a unified, scalable, and maintainable platform that seamlessly integrates event management, community engagement, and communication.

pythonjavascriptandroid+7
Student: Nimeshan
Code

FOSSology & LicenseDb UX and UI design

intermediate
FOSSology•2026Varies175h (Medium)

This project aims to redesign the remaining FOSSology pages and LicenseDb to further modernize the interface and improve overall usability. The redesign will focus on improving navigation, enhancing visual hierarchy, and maintaining a consistent, scalable design system across both platforms. The project will follow a user-centered design approach, including usability evaluation, user research, workflow improvements, and iterative feedback. A reusable component library and cohesive design system will be designed and followed to ensure scalability and long-term maintainability. By improving usability and consistency across FOSSology and LicenseDb, this project will help reduce the learning curve, improve efficiency, and enhance overall user experience.

linuxpostgresqlc/c+++7
Student: Devanshi Sachan
Code
Proposal

A Generalized RAG-LLM Workflow Support Tool for JuliaHealth

advanced
The Julia Language•2026Varies350h (Large)

This project addresses the challenge of unreliable LLM outputs in complex health informatics workflows by building a domain-grounded Retrieval-Augmented Generation (RAG) system within JuliaHealth. It enables users to convert natural language queries into accurate, executable FunSQL.jl workflows by grounding responses in curated resources like OMOP and OHDSI. The project will deliver a modular baseline RAG pipeline, a reproducible evaluation framework to benchmark query quality, and clear documentation with an end-to-end demonstration for usability and future extension.

cjavascriptc+++12
Student: Param Thakkar
Code
Proposal

Automated Artifact Detection And Annotation

intermediate
LibreHealth•2026Varies175h (Medium)

The radiology Artifact Detection aims to create a system that identifies image artifacts on user selected regions of interest. till now the radiologists are manually finding the artifacts . in this project i aim to create a system that helps the radiologists in this process . The scanning reports will contain 100's of scripts and the traditional segmentation models works on pre trained data and breakdowns when it encounters a rare or a completely new data. The solution which i have planned is using an MedSAM model as it classify the scanning reports based on the visual signatures of the user's selection. A 2.5D volumetric tracking in this once an artifact is identified on Slice N, the algorithm prioritizes searching the exact spatial coordinates on Slices N-1 and N+1 which reduces the requirement of computation power. planning of using the human in the loop method in which out of 10 if the 8 predictions are correct and 2 are wrong if the user deletes 2 wrong predictions then the model learns that these two are wrong. i planed of using DICOM for datamanagement. The structure: Frontend -> model -> datainput -> MedSAM model -> loss calculation and scoring -> datamanagement.

mysqljavascriptjava+6
Student: Tejas S A
Code
Proposal

Capa - Native Script Analysis Support

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

This project involves working with Capa, a tool which detects capabilities in executable files. The rationale behind the project is that, current static analysis tools often struggle with scripting languages because of its reliance on fragile regular expressions that can be easily evaded . So, this project aims to extend the capa engine to natively support the static analysis of scripting languages using Tree-sitter. I plan to solve it by working towards the merging the tree-sitter implementation pull request. Once it is merged, I plan to extend the tree-sitter to support more languages of which Bash and Powershell are in my priority list. Then, I will extend the feature extraction of the tree-sitter to have more detailed analysis. Next, I plan to write the capa rules which would verify the integration. Also, I will add relevant documentation for ease of developers and contributors. I plan to deliver all the goals mentioned above within the 12 weeks timeline. Beyond GSoC, I plan to stay involved by contributing code, reviewing pull requests and participating in community discussions.

pythonida-proGhidra+1
Student: saniyafatima07
Code
Proposal
Showing 817 - 840 of 11996 Projects
3334353637
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal