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

Deep Graph Anomaly Detection with Contrastive Learning for New Physics Searches

advanced
Machine Learning for Science (ML4SCI)•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 →
350h (Large)

This project proposed to develop a graph-based unsupervised Anomaly Detection model for identifying new physics at the LHC, combining contrastive learning with graph autoencoder reconstruction. While combining these two signals has proven effective for general graph anomaly detection, it has not yet been applied to particle collision data. Building on prior GENIE work on graph variational autoencoders, the project will explore graph construction strategies, GNN architectures, and contrastive learning objectives tailored to HEP data. Deliverables include a trained graph-based anomaly detection model, benchmark results with comparison to convolutional autoencoder baselines, a comprehensive report, documented codebase, and a blog post.

pythonmachine learningc+++2
Student: Yeyang
Code
Proposal

Agentic RAG on Kubeflow — Multi-Index Retrieval with Kagent & MCP

intermediate
Kubeflow•2026Varies175h (Medium)

Kubeflow's documentation, GitHub issues, and platform code are spread across dozens of repositories with no unified search. This project evolves kubeflow/docs-agent from a single-tool retrieval script into a multi-index Agentic RAG architecture with three MCP search tools (docs, issues, code), domain-specific ingestion pipelines (KFP), and a "Thin Context" MCP flow for IDE integration. All orchestration uses Kagent CRDs (Kubernetes-native). Deliverables: (1) Three MCP tools with dedicated Milvus collections and specialized chunking — issues at comment boundaries, code at YAML/AST boundaries; (2) Project's first test suite (71+ tests) with CI; (3) Idempotent pipeline upserts replacing the current destructive drop-and-recreate; (4) Developer IDE configs for Cursor/Claude Desktop; (5) Feedback logging for golden dataset accumulation; (6) RAGAS evaluation pipeline. Core work (PRs #140, #143) is already built and live-tested on OCI with 2,108 real chunks indexed.

pythontensorflowkubernetes+5
Student: Rohit Kumar (Kmrrohit)
Code

Improve Integration Tests Coverage for OpenELIS

intermediate
OpenELIS Global•2026Varies175h (Medium)

The current Integration Test coverage is still low. This project aims at extending and creating more Integration Tests to achieve a Test Coverage of at least 60% for the Back end Service and Controller Layer

postgresqljavascriptjava+2
Student: Agaba Derrick
Code
Proposal

Hardware in the loop CI

intermediate
GNU Radio•2026Varies175h (Medium)

GNU Radio’s current CI system relies on software-based testing, which cannot capture real-world SDR behavior and hardware-specific issues that arise under actual RF conditions. This limits the reliability of validating signal processing blocks before deployment. This project proposes a Hardware-in-the-Loop (HIL) Continuous Integration framework using CortexLab to extend GNU Radio’s CI pipeline with automated hardware validation. The system detects hardware-relevant changes in pull requests, maps modified blocks to predefined test configurations via a registry, and generates experiment artifacts (tx.py, rx.py, analyze.py, scenario.yaml) dynamically. To ensure efficient resource usage, the pipeline introduces a maintainer-controlled HIL execution step, allowing prioritization of critical PRs instead of fully automatic triggering. After reserving SDR nodes, a lightweight validation test is executed to verify hardware readiness before running full experiments. Each experiment is executed iteratively across multiple input configurations, and results are analyzed using block-specific metrics such as frequency error, amplitude deviation, SNR, BER, and stability. The system produces structured outputs that determine a final PASS/FAIL decision integrated into the CI workflow. Robust error handling mechanisms are included to manage failures in node allocation, execution, and result analysis.

pythonc++dsp+6
Student: Sayantan Maity
Code
Proposal

komamripy - Python Wrapper for KomaMRI

advanced
The Julia Language•2026Varies350h (Large)

KomaMRI.jl is a high-performance Julia package for MRI simulation and differentiable workflows, but its use is currently limited to the Julia ecosystem, creating a barrier for the broader Python-based scientific computing and machine learning community. This project introduces komamripy, a lightweight Python wrapper that exposes KomaMRI’s core simulation and differentiable capabilities through a minimal, intuitive API. The approach leverages Julia–Python interoperability to map data structures between environments, incorporates Julia-side precompilation to reduce first-use latency, and enables flexible GPU backend support across CUDA, AMDGPU, Metal, and oneAPI. The project will deliver a pip-installable Python package with CI-tested builds and automated releases, precompiled simulation and autodiff workflows, cross-platform GPU backend selection, and a validated end-to-end example demonstrating differentiable RF pulse optimization using JAX, along with supporting documentation and example scripts.

cjavascriptc+++12
Student: Anvika Singhal
Code
Proposal

Automated Webpack Documentation Pipeline

intermediate
webpack•2026Varies175h (Medium)

Webpack's extensive API definitions are currently locked inside raw types.d.ts files, creating a significant manual maintenance burden to keep the public documentation synced. My proposal solves this by building an automated, version-aware CI/CD pipeline. I will extract TypeScript ASTs using TypeDoc, format them via typedoc-plugin-markdown with a custom webpack-doc-kit theme, and integrate them into @node-core/doc-kit. The final deliverable is a polished, searchable React-based UI that matches Webpack's visual identity, completely removing the manual documentation overhead from the core team.

javascriptnode.jsweb development+6
Student: Mo_Shams
Code
Proposal

[GSOC-273] Test optimization and integration of a resource and security monitoring system

advanced
Apache Software Foundation•2026$6k–$13.2k350h (Large)

This project delivers an integrated framework to optimize cost, strengthen governance, and improve security operations for Apache Beam resources on Google Cloud Platform (GCP). Key deliverables include: GCP Cost Optimization for Taxi Pipelines: A targeted optimization effort for NYC taxi-related Beam tests and examples to reduce unnecessary Pub/Sub and Dataflow consumption. The work includes execution-bound controls, reusable datasets/snapshots, and safer cleanup practices to preserve reproducibility while lowering operational cost. GCP Resource Governance via IaC: A Terraform-based Infrastructure as Code baseline to define and enforce labels, TTL metadata, ownership fields, and lifecycle policies for high-cost services (BigQuery, Dataflow, Compute Engine, Artifact Registry, and Cloud Storage). This enables a version-controlled, auditable, and repeatable infrastructure governance model. Automated Inventory and Drift Detection: A continuous inventory and compliance pipeline integrated with GitHub Actions, BigQuery, and dashboards. The system will collect resource state, classify orphaned/non-compliant assets, run Terraform validation/plan checks, and detect drift between current infrastructure and declared baseline. Service Key Compliance Monitoring: An operational monitoring flow for service account keys that tracks rotation health, propagation status, TTL violations, and suspicious usage signals, with automated reporting and alerts. Safe Remediation Workflows: Disable-then-delete playbooks executed first in dry-run mode and later in controlled execution, providing secure and traceable cleanup of obsolete resources based on validated policy outcomes.

pythonjavascriptjava+7
Student: Hansel Tepal
Code

WebRTC-HTTP Egress Protocol (WHEP)

intermediate
FFmpeg•2026Varies175h (Medium)

FFmpeg can send WebRTC streams via WHIP but has no way to receive them. This project fills that gap by implementing a WHEP demuxer in libavformat, built on top of the existing WHIP code. The plan is to reuse SDP, ICE, DTLS, and SRTP as much as possible and just flip the direction. The end goal is making ffplay whep://server/stream work, with a clean patch series ready for ffmpeg-devel.

cgitasm+3
Student: Nariman Sayed
Code
Proposal

Hardening Astropy's Core Stability

advanced
OpenAstronomy•2026Varies350h (Large)

Astropy’s Python API is well-tested, but its underlying compiled layer (C, C++, Cython) lacks isolated testing. Because performance-critical extensions are currently only tested indirectly via high-level Python calls, deep bugs can easily be masked. This testing blind spot also blocks major architectural milestones, including the APE low-level package split, the Meson build system migration, and support for Python 3.15 free-threaded builds. This project will build a dedicated test suite to exercise each compiled extension module directly, entirely bypassing the public Python API. By engineering methods to probe these modules in isolation, including resolving complex runtime circular dependencies like `unit_list_proxy.c`; this work will establish a robust, reliable testing boundary between Python and the compiled code. Deliverables: C-API Audit: A mapped testing surface for active compiled extension modules. Isolated Test Suites: Direct pytest suites for compiled modules in astropy/table, time, timeseries, utils/xml, wcs, and erfa. Dependency Resolution: A C-level refactor (or minimal Python stub) to fix the `unit_list_proxy.c` circular dependency. Documentation: A new TESTING_EXTENSIONS.rst guide in Astropy's docs detailing how to run and extend these direct tests.

cpythonjulia+7
Student: Reem_Hamraz
Code
Proposal

Optimize Nest GraphQL API and CI/CD.

advanced
OWASP Foundation•2026Varies350h (Large)

The project should fix the N+1 queries problems across the project with DataLoaders. The file run-ci-cd.yaml should will be split into 5 files and the docker layer will be removed.

pythonjavascriptjava+10
Student: Ahmed Gouda
Code
Proposal

CLI Tools for Efficient MCMC Inference in TuringLang

intermediate
The Julia Language•2026$3k–$6.6k175h (Medium)

This project develops agent-accessible CLI tooling for the Julia Bayesian ecosystem, delivering three main components: DoodlePPL CLI for model validation, code generation, sampling, and diagnostics with structured JSON output, MCMCChains.js, a TypeScript npm library enabling MCMC diagnostics and visualizations in the browser and TuringCLI, a command-line interface for Turing.jl that provides machine-readable JSON outputs, with all three deliverables building upon and extending the GSoC 2025 work on DoodleBUGS.

cjavascriptc+++12
Student: Shravanpuri Goswami
Code
Proposal

End to End Open Verifiable LLM: Deterministic Training & Verification

intermediate
AOSSIE•2026Varies175h (Medium)

Open-weight LLMs are reproducible in principle but not verifiable in practice. You can download weights, but you cannot prove what data they were trained on or whether they were modified later. This project closes that gap by building a training pipeline where identical configurations produce identical model states, and any deviation is cryptographically detectable. A key insight from my experiments is that while training computation can be deterministic, PyTorch’s .pt serialization breaks verification: identical weights can produce different checkpoint files. This project resolves that by verifying tensor-level state using byte-stable formats rather than file-level artifacts. The deliverable is a 1B–3B model trained on a pinned Wikipedia dataset, along with a public manifest that enables independent reproduction and audit.

pythonjavascriptswift+8
Student: ryoari
Code

Ninja Build Backend for DUB

advanced
D Language Foundation•2026Varies350h (Large)

This project adds a Ninja build backend to DUB, the D package manager and build tool used by the D ecosystem. Currently, DUB primarily drives builds via direct compiler invocations. This limits incremental build performance, parallelism, and integration with modern build tooling. The proposal introduces a backend that allows DUB to generate Ninja build files and delegate compilation to Ninja. This enables faster incremental builds, better dependency tracking, improved parallel execution, and easier IDE/toolchain integration.

linuxmaked+2
Student: Hariprakash V
Code
Proposal

Bring Scarpe (shoes) to the TUI

beginner
Ruby•2026Varies90h (Small)

Building modern Text User Interfaces (TUIs) often forces developers to choose between writing complex, low-level terminal sequence code or adopting restrictive, framework-specific solutions. This project addresses this fragmentation by bringing the universally beloved, declarative Shoes GUI DSL (via the Scarpe project) to the terminal environment, allowing developers to build complex CLI applications intuitively. The proposed solution leverages a robust, dual-language architecture. The frontend consists of a pure-Ruby DSL where developers define UI layouts and business logic. The backend is a custom-built, high-performance Rust rendering engine responsible for flexbox-like layout calculations, double-buffered differential rendering, and non-blocking event polling. These two layers communicate seamlessly in real-time through a memory-safe C-FFI (Foreign Function Interface) bridge, ensuring the Ruby VM is never blocked by terminal I/O. By the end of the project, the clearly defined deliverables are: 1) A Universal Low-Level TUI C-API: A standalone Rust rendering engine exposing a clean C-ABI, making it usable not just by Ruby, but by any FFI-capable programming language. 2) The scarpe-tui Ruby Backend: A complete mapping of core Shoes elements (stack, flow, button, edit_line, styling, and clipping) to the terminal grid. 3) An Advanced Showcase Demo: A complex, asynchronous CLI application (inspired by "Claude Code") featuring scrollable histories and bidirectional data flow, proving the framework's readiness for real-world production use. 4) Comprehensive Documentation and Test Suites: Ensuring maintainability and easy community adoption.

rubycjava+3
Student: TureCatedu
Code
Proposal

Enhancement of gcd for polynomials in the sparse representation

advanced
SymPy•2026Varies350h (Large)

This project aims to enhance SymPy's GCD computation speed for polynomials in the sparse representation. I will implement Zippel's algorithm from scratch and finalize the integration of the sparse subresultant PRS algorithm. Subsequently, I will develop a benchmarking suite to evaluate all SymPy's GCD algorithms. The resulting data will serve a new heuristic-based dispatcher, ensuring SymPy selects the optimal strategy for any given input.

pythonc++numpy+1
Student: luca-berton1
Code
Proposal

Support for horizontal scaling of OpenMRS instances.

intermediate
OpenMRS•2026Varies175h (Medium)

OpenMRS has historically operated as a single-instance application, creating a "hard ceiling" for scaling and a single point of failure. As global healthcare networks grow, there is an urgent need for High Availability (HA). While foundational work on distributed caching and storage was introduced in version 2.8.x, several critical gaps remain: lack of distributed session management, race conditions during cluster startup, duplicate execution of scheduled tasks, and inconsistent search indexes across nodes. This project aims to complete the "Cluster-Ready" roadmap for OpenMRS 3.x. Drawing inspiration from proven architectures like Confluence Data Center, I will implement a Zero-Footprint, Multi-Replica framework. I hope to do this by Implementing a formal "Local Home vs. Shared Home" split to manage node-specific vs. cluster-wide data. I want to make use of distributed State Introducing Redis and MySQL-backed session management so users remain logged in even if routed to different replicas. Leveraging Infinispan to implement distributed task locking (preventing duplicate background jobs) and a "Cluster Safety" mechanism to detect and mitigate split-brain scenarios. Transitioning Hibernate Search to a shared OpenSearch/Elasticsearch backend to ensure search consistency across the entire cluster. Project Deliverables: A safe startup sequence for containerized environments (Kubernetes/Helm). Configuration-driven support for Redis (Redisson) and JDBC session persistence. A wrapper for the OpenMRS SchedulerService to ensure tasks run on exactly one node. Audit and migration of O3 modules (FHIR2, Webservices.rest) to the distributed cache manager. Application-level wiring for shared full-text search indexes. A robust integration testing framework using Testcontainers to validate cluster behavior in CI/CD.

javahtml5groovy+11
Student: Suubi Joshua
Code
Proposal

Integrating velocity modelling into PCNToolkit package

intermediate
INCF•2026Varies175h (Medium)

The project aims to improve longitudinal normative modelling in PCNtoolkit by validating, debugging, and extending velocity-based models to support multiple timepoints per subject. The work will include integrating the updated models into the toolkit’s modular architecture, adding tests and documentation, and developing functionality for predicting individual brain changes over time from multiple past observations.

pythonjavac+++7
Student: Maria Glushanina
Code
Proposal

Zplit: Completing a Decentralized, Privacy-First Group Expense App w ith P2P Sync,

intermediate
AOSSIE•2026Varies175h (Medium)

Zplit is a decentralized, privacy-first group expense tracking application designed to give users full control over their financial data without relying on centralized servers. Unlike traditional apps, Zplit operates using peer-to-peer technologies such as Wi-Fi Direct, Bluetooth, NFC, and QR codes, enabling seamless offline-first collaboration.I will implement Deep Link integration for seamless group invitations, integrate USDC/DAI stablepay settlement for expense splitting, and build interactive data visualizations . All user data will be synced peer-to-peer via Wi-Fi Direct, Bluetooth, NFC, and QR codes, ensuring zero cloud dependency. The final deliverables will include a fully functional Flutter app with Deep Link support, stablepay payment flow, expense visualization dashboard

pythonjavascriptswift+8
Student: janvi pithadiya
Code

Integrate a client for buildingSMART Data Dictionary web service.

intermediate
FreeCAD•2026Varies175h (Medium)

This project will build and integrate a Python-based client for the buildingSMART Data Dictionary (bSDD) directly into FreeCAD's BIM Workbench. This integration will allow users to dynamically search and apply international classification standards from the cloud, providing context-aware suggestions based on the underlying IFC entity. To ensure a stable and non-disruptive integration, the project will implement a "dual-layer" data model. This approach will securely store the rich, web-fetched bSDD metadata while automatically populating the existing legacy string properties, guaranteeing 100% backward compatibility with FreeCAD's current stable workflows.

pythonc++qt+2
Student: Parag Debnath
Code
Proposal

General Brush Engine Improvements

intermediate
Blender Foundation•2026Varies175h (Medium)

Features 1. Per-brush opt-in for scene-level brush settings (“use unified xxx”). 2. Brush tip roundness (currently available in limited brushes). 3. Customizable pressure curves for all pressure-sensitive parameters. 4. Customizable brush toggling and improved toggle display. 5. Improved first-stroke responsiveness across relevant brushes. 6. Pressure handling improvements in anchored mode. Deliverables 1. Tip roundness and tilt support across all relevant brushes. 2. Per-brush “use unified xxx” support. 3. Custom curve controls for all pressure-sensitive parameters, including auto-smooth and hardness. 4. Improved brush toggle UI and behavior. 5. Improved first-stroke responsiveness for relevant brushes. 6. Improved anchored-mode pressure handling. 7. End-user documentation for new features.

cpythonopengl+3
Student: Jerry Wei
Code
Proposal

RSS news reader

advanced
KolibriOS Project Team•2026Varies350h (Large)

The Goal: A 100% x86 Assembly (FASM) news reader that replaces bloated web browsing with high-performance, native headlines. The Strategy: Use FEED struct array allocation (with a +5 buffer) for O(1) efficiency and a Unified Schema Engine to parse RSS. Core Deliverables: a state-driven, 2-pane GUI with "Read/Unread" tracking, a modular backend for http.obj networking and asmXml parsing, and a headless test harness.

cassemblyasm+2
Student: Francesco Pio Mastrorilli
Code
Proposal

Behavioral evals, Quality, and the OSS Community

advanced
Gemini CLI•2026Varies350h (Large)

This proposal focuses on improving the behavioral evaluation (eval) infrastructure of Gemini CLI to ensure reliable and safe AI tool usage. The current system has significant gaps, including missing eval coverage for ~37.5% of tools, a large number of non-CI-blocking (flaky) tests, and lack of tooling for debugging and contributing to evals. To address this, the proposal introduces a three-part approach: Expand and Stabilize Behavioral Evals Write 15–20 new evals covering uncovered tools and missing behaviors (error recovery, multi-step reasoning, safety, ambiguity handling). Stabilize flaky evals and promote reliable ones to CI-blocking status. Focus on testing tool-call decisions instead of text output for robustness. Enable Contributor Participation via Skills & Subagents Introduce an eval-writer skill to help generate evals. Build subagents like eval_investigator (debugging failures) and quality_analyst (coverage analysis). Make eval development accessible to open-source contributors. Fix Ecosystem Gaps (Process, Tooling, Documentation) Define clear eval review, promotion, and regression-handling processes. Improve logging with readable tool-call traces. Create the Eval Development Kit (EDK) with tools for: Eval inventory & coverage analysis Validation checks Auto-generating evals from real chat logs Add documentation, tutorials, and GitHub automation for easier community contributions. Overall, the goal is to transform evals from a limited internal system into a scalable, contributor-friendly quality framework, enabling the OSS community to actively improve AI behavior, reliability, and performance.

typescriptGenAIMCP+2
Student: VedantxMahajan
Code
Proposal

Enhance Similarity Maps (Embeddings) Visualization

intermediate
cBioPortal for Cancer Genomics•2026Varies175h (Medium)

cBioPortal introduced Similarity Maps, a feature that visualizes UMAP/PCA embeddings of cancer samples, allowing researchers to discover hidden patterns across thousands of samples simultaneously. However, the current implementation is a prototype that fetches data directly from a hardcoded S3 URL, bypassing cBioPortal's data pipeline entirely and following no established datahub standards. This project makes Similarity Maps production-ready by building a proper data layer that follows cBioPortal's existing architecture. This includes designing a datahub file format for embeddings, reusing/extending the existing importer to load embedding data into ClickHouse, and exposing REST API endpoints that replace the hardcoded S3 fetch. The frontend will then be updated to consume the new API dynamically. Additionally, enhanced tooltips and improved colouring options will be implemented to strengthen the visualization. Key deliverables include: an approved database schema, a working EmbeddingImporter.java, a validated datahub file format, REST API endpoints, updated frontend integration, and full documentation

javascriptjavaweb+9
Student: Leslie Ejeh
Code

Agentic Question Answering over DBpedia - Malla Siddharth Reddy

advanced
DBpedia•2026Varies350h (Large)

Accessing the billions of facts stored in DBpedia's knowledge graph currently requires writing SPARQL queries, putting this incredible resource out of reach for most people. This project tackles that by building a self-correcting Agentic Question Answering system over DBpedia using LangGraph and Qwen3. Rather than attempting one-shot translation like existing Neural SPARQL Machine approaches, which frequently fail when a model hallucinates a property or misresolves an entity, the system grounds the entire reasoning process through a pipeline of deterministic tools including an Entity Linker with a GraphRAG FAISS fallback for ambiguous mentions, a live Ontology Explorer that discovers what predicates actually exist for a given entity, and a Schema Introspector that validates property types before query construction. The core contribution is a conditional self-correction loop where a Validator node diagnoses exactly what went wrong and dynamically routes the agent back to the specific tool needed to fix it, whether that is the entity linker, the predicate explorer, or the query builder, enabling the system to recover from failures instead of collapsing silently. The final pipeline will be rigorously benchmarked against QALD-9-plus and the DB25 dataset from the Text2SPARQL 2025 challenge, providing open, hallucination-free natural language access to the Semantic Web.

javascalardf+7
Student: Malla Siddharth Reddy
Code
Proposal
Showing 649 - 672 of 11996 Projects
2627282930
Proposal
Proposal
Proposal
Proposal
Proposal