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

Real-Time Audio Capture and Playback Pipeline for Zephyr with Optional ML Integration

advanced
The Linux Foundation•2026$6k–$13.2k

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)

Zephyr provides low-level I2S and DMIC driver APIs along with a few narrow samples (echo, codec), but lacks a reusable application-layer audio pipeline that handles real-world complexity. The closest prior effort (GSoC 2025, PR #96657) attempted to integrate TensorFlow Lite Micro Micro Speech with a Linux host streaming setup, but the audio pipeline was tightly coupled with ML logic, limiting extensibility and resulting in fragile real-time behavior. A clean abstraction to support multiple backends is still absent. This proposal addresses these gaps by introducing a modular, backend-agnostic audio pipeline, designed around fixed-size PCM blocks and explicit ownership semantics. The system will support continuous audio streaming at 16 - 48 kHz, 16-bit PCM, targeting 4 - 10 ms frame latency with zero TX underruns and zero RX overruns under sustained load. Key deliverables include a pipeline API, support for multiple backends (I2S, PDM, optional USB), and reusable processing stages such as format conversion, and ML inference as an upstream sample.

cpythonmysql+7
Student: mohittalwar23
Code
Proposal

Reactive Simulation and Analytics Integrating marimo with gprMax

intermediate
gprMax•2026Varies175h (Medium)

gprMax users currently visualize simulation output using static terminal scripts with no interactivity. This project builds a reactive web-based dashboard using marimo, replacing that workflow with four components: parameter controls with live geometry preview, a simulation progress tracker, post-processing visualization for A-scans and B-scans, and a set of Reactive Recipes for common modelling scenarios. A working prototype covering all three visualization components is already built and running against real gprMax HDF5 output on the devel branch.

pythoncythoncuda+3
Student: Gaurav.Sharma
Code
Proposal

Predictively Oriented Posteriors in PyMC

intermediate
NumFOCUS•2026Varies175h (Medium)

Standard Bayesian posteriors degrade under model misspecification by collapsing to point estimates. This project implements Predictively Oriented (PrO) posteriors in PyMC, a theoretically principled sampler that provides uncertainty calibrated to predictive reality rather than parameter estimation. The implementation includes a scoring-rule abstraction, Wasserstein gradient computation via PyTensor, vectorised particle simulation, and ArviZ integration with tutorials demonstrating robustness on real datasets.

pythonjavascriptr+3
Student: eclipse
Code
Proposal

CampWiz Nxt Redesign

beginner
Wikimedia Foundation•2026Varies90h (Small)

CampWiz NXT is the jury management platform used during Wiki Loves contests to evaluate media submissions, images, audio, and video, uploaded to Wikimedia Commons. It provides a structured environment for jurors and organisers to assess, score, and process contest entries at scale. The current implementation uses a dual-server architecture: a Next.js frontend and a Golang backend. While functional, this setup introduces real costs. There is server component complexity, a persistent Node.js process required for deployment, and an interface that places more cognitive burden on jurors than the work itself demands. These are solvable problems, and solving them is what this project is about. The goal is to migrate the frontend from Next.js to a pure React application built as a static output with Vite. This is not a surface-level reskin. The migration removes the Node.js server dependency entirely, allowing the frontend to be served over standard HTTP, making deployment simpler, cheaper, and more maintainable. The Golang backend remains unchanged; only the frontend layer is being replaced. Alongside the technical migration, the interface will be redesigned with a deliberate focus on clarity and minimalism. Jurors should be able to open the tool and immediately focus on reviewing submissions, not on navigating a cluttered interface. Non-essential actions will be removed from the juror viewport, decision controls will be streamlined, and keyboard accessibility will be enforced throughout. The organiser dashboard will receive the same treatment: clean workflows for contest setup, juror assignment, and results management, without requiring backend access for routine configuration. The result will be a frontend that is easier to deploy, easier to maintain, and noticeably better to use.

javascripthtmlphp+7
Student: Pius Osuji
Code
Proposal

Switched Ethernet

intermediate
The ns-3 Network Simulator Project•2026Varies175h (Medium)

Design a modular switched Ethernet model capable of simulating 1, 10, and 40 GbE links, with MAC-based auto-learning of I/O ports, support for pluggable scheduling algorithms (FCFS, WRR), while remaining extensible for future support of VLAN and Spanning Tree protocols, introduce enhanced EthernetNetDevice model with point-to-point–like NetDevice abstraction for switched Ethernet, an EthernetChannel capable of simulating both half-duplex and full-duplex modes of operation responsible for modeling transmission delay and errors.

pythonc++c/c+++2
Student: Manmita Das
Code
Proposal

Plugin Modernizer Stats Visualization

intermediate
Jenkins•2026Varies175h (Medium)

The project aims to build a trusted Jenkins CI pipeline that fetches and consolidates raw metadata from metadata-plugin-modernizer repo into a single structured JSON format, which is published to reports.jenkins.io. It also involves building a static visualization UI site on top of it that consumes this data during its build process to present dashboards and per-plugin reports.

javascriptjavago+2
Student: _Pratik Mane
Code
Proposal

System Tests Improvements for preCICE

advanced
preCICE•2026Varies350h (Large)

This project aims to improve the system testing framework of preCICE to make end-to-end simulations faster, more reliable, and easier to extend. Currently, system tests involve building multiple combinations of tutorials, adapters, and core versions using Docker, executing coupled simulations, and validating outputs against reference data. The project will focus on optimizing test execution time through parallelization and caching strategies, improving result validation and reporting for better debugging, and enhancing the modularity of test configurations to simplify adding new scenarios. Additionally, improvements in CI integration will ensure more robust and automated testing workflows. The expected deliverables include a redesigned and optimized system testing pipeline, improved reporting mechanisms, reduced execution time, and comprehensive documentation for contributors. These enhancements will strengthen the reliability and scalability of preCICE’s testing infrastructure.

cpythonshell+1
Student: Pranjal Manhgaye
Code
Proposal

AI Driven Printer Compatibility and Recommendation Portal

intermediate
The Linux Foundation•2026Varies175h (Medium)

OpenPrinting maintains detailed Linux printer compatibility data through Foomatic, but users lack an intuitive way to discover or evaluate printers. This project builds a fully static printer discovery and recommendation portal on the OpenPrinting website, deployable on GitHub Pages with no backend. It enables users to search, filter, compare printers, and receive explainable recommendations based on precomputed similarity data.

cpythonmysql+7
Student: Gati Varshney
Code
Proposal

OptimizationJob CRD for Hyperparameter Optimization in Kubeflow Katib

intermediate
Kubeflow•2026Varies175h (Medium)

This project addresses limitations in Kubeflow Katib current Experiment CRD, which uses a generic and loosely typed interface for hyperparameter optimization. This leads to fragile parameter injection, inefficient resource usage, and unreliable state handling for stateful algorithms. To solve this, I propose designing and implementing a new OptimizationJob CRD v1alpha1, a strongly typed API focused on hyperparameter optimization for TrainJobs. It introduces native parameter injection, persistent algorithm state handling, and a push-based metrics pipeline integrated with the TrainJob Progress API. The project will deliver a production-ready controller with a structured reconciliation loop, support for stateless and stateful optimization algorithms, SDK integration, and comprehensive testing, resulting in a more reliable and efficient HPO workflow.

pythontensorflowkubernetes+5
Student: Aniket Shaha
Code

Apache SkyWalking Natural Language to BydbQL

advanced
Apache Software Foundation•2026Varies350h (Large)

This solution addresses the problem that BanyanDB / BydbQL has a high usability barrier, making it difficult for users to accurately translate natural language queries into executable query statements. In real-world observability and operations scenarios, users often lack deep understanding of query syntax, schema structures, and query patterns, resulting in low efficiency and high error rates. To solve this, the proposal designs and implements an NL2BydbQL intelligent query agent. Leveraging large language models and the LangGraph reasoning framework, the agent converts natural language into executable BydbQL. The system combines RAG (grammar rules, few-shot examples, schema semantics), MCP-based real-time schema awareness, and a multi-stage reasoning pipeline to form a complete loop from intent understanding to query generation and validation. The core approach includes: Building a structured knowledge system (Grammar Rules, Few-shot Examples, Schema Semantic Docs) Designing a dual-path reasoning mechanism (QA vs. Workflow) with dynamic routing based on query complexity Introducing an intermediate representation (IR) to unify generation and repair Ensuring query correctness via parser validation and automatic repair Incorporating runtime feedback and session memory for continuous improvement The deliverables include: A production-ready NL2BydbQL agent (based on LangGraph) A set of structured RAG datasets (grammar, examples, schema descriptions) A complete and extensible reasoning workflow design End-to-end capabilities including query generation, auto-correction, clarification interaction, and execution feedback loop This solution significantly lowers the query barrier and improves the usability and efficiency of SkyWalking and BanyanDB in intelligent operations scenarios.

pythonjavascriptjava+7
Student: Jingyi Qu
Code
Proposal

Evaluating Structured Reactive Patterns in Atmos

advanced
LabLua•2026Varies350h (Large)

My work involves porting the game SNKRX from Lua to Atmos, a versatile programming language that is based on concurrency, event-driven programming. The project focuses on replacing imperative Lua patterns—such as manual flag management and nested callbacks—with the main functionalities of Atmos to simplify complex game logic. Specific tasks include refactoring the screen management system into a hierarchy of scoped tasks, converting global variables into linear sequences, and modularizing character ability chains. Throughout the process, the project will measure how these reactive and parallel features improve code maintenance compared to the original implementation.

luacéuelasticsearch+5
Student: kboltiz
Code
Proposal

Adding Support for the Scrutiny Debugger Instrumentation Library

beginner
RTEMS Project•2026Varies90h (Small)

This project will integrate the Scrutiny Embedded instrumentation library to RTEMS. The result of this project will be an instrumentation interface that provides in-field debugging and an alternative to JTAG-based stop mode debugging, which is particularly useful for hobbyists and beginners, or for those debugging systems which are live. Deliverables will include a working two-way UART transport, integration of Scrutiny functions to RTEMS, the ability to expose specific metrics from RTEMS to Scrutiny, a user facing API for developers, a package under the RTEMS Source Builder titled rtems-scrutiny, and the necessary test suites for all use cases. This effort will provide RTEMS users with an effective Scrutiny port which can then successfully be hooked up to their respective clients for streamlined debugging.

cpythonembedded systems+5
Student: aftwasiq
Code

Enhance Slang with Separate Compilation

intermediate
Pharo Consortium•2026Varies175h (Medium)

The Pharo VM is written in Slang, a Smalltalk subset that is transpiled to C by the CCodeGenerator. Currently, the entire VM is generated into a handful of large monolithic C files where code from completely different subsystems the garbage collector, the interpreter, and the JIT compiler are all merged together into a single output stream. This makes the generated code difficult to read, navigate, and maintain, and means that changing a single method triggers recompilation of the entire VM rather than just the relevant module. This project introduces separate compilation to Slang by refactoring CCodeGenerator to route generated C code into multiple files, one per class hierarchy, while correctly tracking and emitting #include dependencies between them. The approach involves extending CCodeGenerator to maintain per-hierarchy output streams, implementing a dependency graph builder to determine which hierarchies reference which others, generating corresponding header files with the necessary forward declarations and prototypes, and updating the CMake build system to automatically discover the new files. The deliverables are: a working dependency graph builder for TMethod objects, a refactored CCodeGenerator supporting multiple output streams, successful extraction of the SpurMemoryManager garbage collector hierarchy into its own standalone C file with correct includes as a proof of concept, header file generation for all separated modules, extension of separate compilation to the Cogit JIT compiler and remaining hierarchies, and an updated CMake build configuration. All existing VM tests will pass throughout, ensuring no regressions in the generated code.

smalltalkroassalpolymath+7
Student: Zinnia Nagpal
Code
Proposal

Rebuild the LateNight theme in QML

advanced
Mixxx•2026Varies350h (Large)

This project will rebuild the LateNight skin as a 100% native QML interface, serving as an act of architectural liberation for the Mixxx codebase. By unwiring decades of complex, hardcoded C++ widget logic, the skin will be migrated to a dynamic, GPU-accelerated declarative ecosystem. This involves writing a dedicated C++ QmlThemeProvider bridge to manage dynamic JSON color palettes and assets, converting legacy WidgetStacks to fluid QML state machines, and assembling the deck structure using scalable DelegateChooser layouts. This deep structural re-engineering ensures the LateNight skin remains performant, responsive, and infinitely customizable for community derivatives on modern and portable hardware.

javascriptc++qt+3
Student: Ayush Sah
Code
Proposal

Upgrade eventyay-video to a Single Page Application

advanced
FOSSASIA•2026Varies350h (Large)

This project upgrades the eventyay video frontend into a modern Single Page Application integrated with ENext . It solves issues like outdated state management, inefficient routing, and the lack of an admin dashboard by introducing a centralized state system, optimized routing, and Vue 3 Composition API. Key deliverables include a real time organiser dashboard, improved performance, and added testing and CI for a more reliable and maintainable platform.

pythonjavascriptandroid+7
Student: Om Vanwari
Code
Proposal

Improve the Pallene Installer

beginner
LabLua•2026$1.5k–$3.3k90h (Small)

The end goal of this GSoC project is to design a simple and portable process for building and installing Pallene on any of the three major operating systems (Windows, macOS, and Linux). The process will not depend on any external services or system-level packages. No dependencies other than Make and a C compiler for building and installing Pallene. Deliverables: - Simplified build process. - Simplified install process. - Eliminating of dependencies on external systems for building and installing Pallene. - Updated documentation with the new steps. - Updated CI script with separate steps for building, testing, linting, and installing Pallene on all three major operating systems. - Reduced dependencies. - Removal of old build scripts.

luacéuelasticsearch+5
Student: njs0707
Code
Proposal

Nest - OWASP Board Activity and Candidate Verification Framework

intermediate
OWASP Foundation•2026Varies175h (Medium)

This project improves transparency in OWASP Board of Directors elections by implementing a verified candidate claims system with a structured multi-reviewer fact-checking workflow and standardizes historical board activity data (meetings, motions, discussions, votes, and resolutions) for programmatic access via REST API and GraphQL.

pythonjavascriptjava+10
Student: Rudransh Shrivastava
Code
Proposal

Alaska_BIO-BLOCK_GSoC'26 (Suryansh Maurya) Project no.6

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

My proposal tackles the critical challenge of making raw medical data safe to share on Bio-Block without destroying its usefulness for machine learning. To achieve this, I'm building a "zero touch" FastAPI ingestion pipeline that acts as an automated watchdog, seamlessly using Microsoft Presidio to scrub sensitive personal health information from text, DICOM files, and medical images before they ever reach storage. Because we still need this data to be valuable for AI research, I'm implementing flexible "Privacy Profiles" that allow the system to intelligently preserve general demographics rather than just blindly deleting every identifier. Finally, since highly anonymized data is very difficult to search through, I'm building a hybrid search engine that combines exact keyword matching (BM25) with context aware semantic search (ChromaDB), ensuring researchers can easily discover the exact datasets they need without running into redundant search results.

pythonmysqljava+2
Student: Suryansh Maurya
Code
Proposal

Expand genome metadata in Ensembl with AI tools

advanced
Genome Assembly and Annotation•2026Varies350h (Large)

The Ensembl Plants and Metazoa platforms face a significant metadata gap where critical biological context, such as ploidy, strain, and sex, is often documented in peer-reviewed literature but missing from formal INSDC sequence archives. This lack of structured metadata, particularly ploidy, creates technical bottlenecks in downstream comparative genomics and requires labor-intensive manual curation. To address this, I propose developing a standalone, Python-based "Retrieve-Extract-Verify" module that leverages Large Language Models (LLMs) and Retrieval-Augmented Generation (RAG) to automate metadata extraction from scientific papers. This tool will utilize literature APIs like Europe PMC, employing section-aware parsing and confidence scoring to ensure high data integrity with minimal human intervention. My previous experience in building Transformer-based bioprocess optimization models and genome-level embeddings directly informs my approach to handling complex biological datasets. The final outcome will be a ready-to-deploy Nextflow module designed for seamless integration into Ensembl’s production pipeline and provide the global research community with richer, more reliable genomic metadata.

pythonmysqljavascript+4
Student: Soomin Lee
Code

DevOps improvement and standardization

intermediate
NumFOCUS•2026Varies175h (Medium)

This project focuses on improving the development and testing infrastructure across the ArviZ ecosystem (arviz-base, arviz-stats, and arviz-plots). While the recent modular split has helped organize the codebase, it has also led to inconsistencies in CI workflows, testing setups, and type checking. The goal of this project is to make these systems consistent, stricter, and easier to maintain across all repositories. To achieve this, we will unify tools like tox and pre-commit, improve type safety using docstub and strict Mypy checks, strengthen test coverage by treating warnings as errors and adding missing tests, and introduce nightly CI testing against upcoming versions of scientific Python libraries. This will help contributors work more easily across repositories and ensure that ArviZ remains stable and reliable for users over time.

pythonjavascriptr+3
Student: Piyush Panwar
Code
Proposal

PyMC Streaming Variational Inference for Large Datasets

intermediate
NumFOCUS•2026Varies175h (Medium)

PyMC's variational inference stack — including ADVI and Pathfinder — assumes all data fits in memory. Real-world applications such as financial tick data, sensor streams, and large panel datasets regularly exceed RAM. This project extends PyMC's variational inference to support true streaming data via arbitrary Python iterables delivering batches, with ELBO estimation from running streams. Deliverables include a StreamingDataset abstraction wrapping iterators with the PyMC minibatch system, streaming-compatible ADVI and Pathfinder training loops using stochastic L-BFGS, online convergence monitoring callbacks, and tutorial demonstrations on financial time series and panel data exceeding memory limits.

pythonjavascriptr+3
Student: Yicheng Yang
Code
Proposal

Support for Lesson Progress Study Guides and Worked Examples

intermediate
Oppia Foundation•2026Varies175h (Medium)

The Oppia Android app is missing three features that the web platform already has. Learners have no idea how far they are in a lesson, revision cards are a flat wall of text with no structure, and worked examples in concept cards are completely invisible. This project adds all three. First, a checkpoint based lesson progress indicator that uses the is_checkpoint state property to show learners their progress as X of N through an exploration, with correct behavior during backward navigation, flashbacks, and checkpoint restoring. Second, structured study guides that replace the flat revision card with a sectioned RecyclerView showing headings and content blocks. Third, a worked example tag handler that parses nested HTML inside oppia-noninteractive-workedexample tags and renders inline Question and Answer blocks using styled spannables. All three features are independently gated behind feature flags and built on top of existing infrastructure.

pythonjavascriptangularjs+10
Student: Neer Aryan Bhatta
Code

Adding Confidence Intervals for Changepoint Detection

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

The central task in this project is to take the mentors’ existing confidence-set prototype and develop it into a maintainable package feature. The key challenge is to remove the current hardcoding around cost functions and replace it with a generic implementation that can support likelihood-based settings, including time series, while still fitting naturally into the existing changepoint workflow. I plan to do this by separating the core confidence-set logic from the algorithm- and cost-specific extraction steps, and then exposing the result through a user-facing interface with methods for summarizing, printing, and plotting the output. If successful, this would turn a research prototype into something that users of changepoint could actually apply in practice.

cc++r+4
Student: Arslan Batyrov
Code

Handwritten Text Recognition for early modern Spanish documents with Vision Language Model creation

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

This project builds an end-to-end Handwritten Text Recognition (HTR) pipeline for early modern Spanish manuscripts by placing a Vision-Language Model (VLM) at the center of every processing stage, not just as a late-stage corrector. The pipeline uses Qwen2.5-VL with LoRA-based multi-task fine-tuning across four stages: document analysis, literal reading, line-level OCR via a fine-tuned TrOCR model, and reconciliation/correction, where the VLM reconciles multiple reading sources using visual and contextual evidence. As a pre-GSoC contribution, I have built and validated this pipeline, achieving a median CER of 0.107 (~89.3% character accuracy) on the Rodrigo dataset with perfect transcription on well-preserved pages. The proposed GSoC work will transform this into a production-ready, multi-model application by abstracting the VLM backend to support multiple open-source models (Qwen2.5-VL 3B/7B/72B, InternVL), adding batch processing for multi-page manuscripts with PDF support, building a locally-run desktop application with a Gradio interface, packaging the pipeline as a pip-installable CLI tool, conducting comprehensive benchmarks and ablation studies across all model backends, releasing fine-tuned model weights on HuggingFace Hub, and providing a training pipeline for researchers to fine-tune on their own manuscript collections. The fully local execution model ensures data privacy for sensitive archival material, while the multi-model architecture allows users to select models based on their hardware constraints and accuracy requirements.

pythonmachine learningc+++2
Student: Aniket Junghare
Code
Showing 289 - 312 of 11996 Projects
1112131415
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal