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

Multi-Object Tracking Integration for OpenVINO Training Extensions (OTX)

advanced
OpenVINO Toolkit•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)

OTX supports 15+ detection models but has no built-in tracking.Every real-world video application (conveyor belt counting, asset monitoring, dwell-time measurement, traffic analysis, sports analytics, etc) needs stable object tracking across frames. This project integrates Multi-Object Tracking into OTX, adding five tracker implementations (ByteTrack, SORT, DeepSORT, OC-SORT, BoT-SORT), a SAM-2-inspired memory bank for re-identification, MOT17 benchmarking, and CLI support along with documentation. The design is decoupled: a new OTXTracker base class owns all temporal state while existing OTX detection models remain untouched.

pythonc++x86+1
Student: Omkar Kabde
Code
Proposal

Modernizing eventyay-flowspace: Migrating to Vue 3 with Modern Jitsi Integration

intermediate
FOSSASIA•2026Varies175h (Medium)

Online conferences are efficient for content delivery, but they still struggle to recreate one core part of in-person events: informal social spaces. Hallway conversations, spontaneous meetups, and unplanned networking moments are often where the most meaningful connections happen. eventyay-flowspace is designed to restore this missing layer by providing a spatial, proximity-based social lounge tightly integrated with Eventyay. The current legacy baseline has major limitations: it is unmaintained, built on Create React App, and depends on the global `window.JitsiMeetJS` integration patterns that are hard to isolate and test.

pythonjavascriptandroid+7
Student: Saksham Sirohi
Code
Proposal

GSOC’26: OOT Module for web-based monitoring of running flow graphs in GNU Radio 4

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

GNU radio (GR) is used in a variety of applications, especially with the focus of GR4 on being flexible enough to work on a plethora of systems. Some of which access to a GUI may not be available (e.g Embedded systems, edge computing nodes) or sharing of the output of the GR4 flowgraph remotely is required. In GR3.x the solution to this was gr-bokehgui, an OOT module created during GSOC 2017 which allowed for remote access of the output of the GR flowgraph through web based plots & widgets. Currently GR4 is being developed and no equivalent tool exists for it leaving a gap in remote monitoring capabilities. GR4 also currently does not have built in blocks for local plotting, this OOT can be considered a stop gap such blocks are added This proposal outlines the development of a OOT module for GR4, serving as a successor to gr-bokehGUI in functionality.

pythonc++dsp+6
Student: Ziad Haithem Fahmi
Code

Structured Format for Saved Circuit Data

intermediate
CircuitVerse.org•2026Varies175h (Medium)

CircuitVerse currently saves circuits based on visual layout rather than logical connections, resulting in unpredictable save files that prevent meaningful version control, complicate Verilog synthesis, and hinder data analysis. To solve this, this project introduces a deterministic, canonical JSON format. By utilising Kahn's algorithm to map dependencies, the new format ensures components are always saved and loaded in the correct sequence, regardless of where they are drawn on the screen. The key deliverables include a smarter export/import engine, an automated, zero-loss migration tool to smoothly upgrade all legacy .cv files to this new standard, a highly optimised single-pass Verilog generator, and an interactive developer UI featuring real-time JSON previews, copying, and downloading.

postgresqljavascriptbootstrap+8
Student: Harkeerat Singh
Code
Proposal

New Module Management UI

intermediate
Learning Unlimited•2026Varies175h (Medium)

ESP-Website administrators currently manage program modules manually with no way to pre-schedule transitions, causing configuration errors that risk corrupting student registration data. This project builds a visual, Gantt-style Module Management UI that lets administrators schedule module open/close windows on a drag-and-drop timeline canvas, with separate student and teacher views, real-time conflict detection, and a time scrubber to preview the student experience at any point. On the backend, ProgramModuleObj will be subclassed from ExpirableModel to add native time-windowing, and five AJAX endpoints will power all frontend interactions. Deliverables include the model migration, time-aware module filtering, the timeline canvas UI, a module picker side panel, full WCAG 2.1 AA accessibility, and bidirectional integration with the existing module questions interface.

pythonjavascriptdjango+2
Student: Supriyo Chowdhury
Code
Proposal

Streamlining Release Automation

intermediate
Oppia Foundation•2026Varies175h (Medium)

Oppia Android's release process currently relies on a 17-page manual document that release coordinators follow step-by-step, covering everything from cutting branches and building binaries to signing, deploying to Play Console, and writing changelogs. This is slow, error-prone, and has caused QA testers to miss builds due to Play Store sync issues. This project replaces that manual process with six GitHub Actions workflows backed by Kotlin scripts that handle building, Cloud KMS signing, Play Console deployment, Firebase App Distribution for QA, LLM-powered changelog generation, and automated weekly alpha releases. All scripts are designed with interface-based abstractions (CloudSigner, PlayConsoleClient, VertexAiClient, GitHubClient) so they can be thoroughly unit-tested with fakes, requiring no real GCP credentials in tests. Security is handled through Workload Identity Federation (keyless auth) and Cloud KMS HSM-backed signing, ensuring the private key never leaves Google's hardware. Deliverables: 6 new Kotlin scripts with full test coverage, 6 GitHub Actions workflows, updated wiki documentation (playbook + manual fallback reference), and an end-to-end demo of the complete release cycle running through CI.

pythonjavascriptangularjs+10
Student: Sandesh Raj
Code
Proposal

Debusine: debuginfod server

intermediate
Debian•2026Varies175h (Medium)

This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.

pythonjavascriptc/c+++8
Student: Jugal59
Code
Proposal

Polyglot P4TC: Python and Rust API Wrappers for Linux TC-based P4

intermediate
The P4 Language Consortium•2026Varies175h (Medium)

P4TC enables programmable packet processing in the Linux kernel via TC and eBPF, but its control plane is limited to the tc CLI and shell scripts. This project delivers idiomatic Python (cffi) and Rust (bindgen) wrappers for P4TC's C API, covering both provisioning and runtime CRUDSP operations. Deliverables include: (1) a Python package (p4tc_py) with context managers and type hints, (2) a Rust crate (p4tc-rs) with safe ownership semantics and Drop-based cleanup, (3) ported tutorial examples in both languages, and (4) API documentation with a shell-vs-Python-vs-Rust comparison guide.

llvmc++mlir+3
Student: Attaullah Ansari
Code
Proposal

Integrating a Remarks Analysis Engine into LLVM Advisor

advanced
LLVM Compiler Infrastructure•2026Varies350h (Large)

This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation restructures the underlying data layer with a high-performance, dual-path ingestion pipeline, primary path being native C++ libRemarks bitstream decoding to process massive LTO builds without memory exhaustion, and the fallback path is YAML ingestion pipeline. It also implements a dependency-free Vanilla JS virtualization grid and injecting "Active Diagnostic" modules (like heuristic hinting and spatial heatmaps) directly into the existing Code Explorer DOM. This provides LLVM developers with bottleneck triage and actionable C++ refactoring advice while still maintaining the tool's lightweight, offline-first design.

cllvmc+++3
Student: kamini08
Code
Proposal

Enterprise & Institutional Organization Features — CircuitVerse

intermediate
CircuitVerse.org•2026Varies175h (Medium)

CircuitVerse currently handles every user and classroom in isolation with no concept of institutional ownership. This makes it impossible for universities to manage hundreds of classrooms, instructors, and students under one umbrella. This project introduces an Organisation layer to CircuitVerse. It adds a hierarchical structure where an Organisation contains Department Groups, which contain existing CircuitVerse classrooms. Role-Based Access Control enforced via Pundit gives each role: Org Admin, Group Lead, Instructor, and Student, exactly the permissions they need and nothing more. Single Sign-On via OpenID Connect lets students log in using their existing institutional email through Google Workspace or Microsoft Azure AD, with automatic org assignment based on email domain. Optional custom branding adds subdomain support and logo placement for institutional identity. Deliverables: 1. Hierarchical org structure: organisations, org_groups, memberships tables with full admin dashboard 2. RBAC via Pundit: four roles enforced at the server level 3. SSO via OIDC: omniauth-openid-connect with domain-to-org auto-assignment 4. Custom branding: subdomain routing and logo rendering (optional)

postgresqljavascriptbootstrap+8
Student: Naman-Chhabra
Code

Implement Make Biconnected Planar and Make Maximal Planar Algorithms for pgRouting

intermediate
OSGeo (Open Source Geospatial Foundation)•2026Varies350h (Large)

This project implements pgr_makeBiconnectedPlanar and pgr_makeMaximalPlanar as new pgRouting SQL functions, completing the planar graph preparation. Together they unlock downstream Boost layout algorithms currently inaccessible to pgRouting users. Stretch goal: pgr_findOddCycle. Estimated 350 hours.

pythonjavascriptc/c+++4
Student: Mohit242-bit
Code
Proposal

Agentic AI for Autonomous Gravitational Lensing Simulation Workflows

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

DeepLenseSim (built on lenstronomy) requires substantial manual intervention for configuring parameters, managing outputs, and iterating on failures across multi-step simulation pipelines, creating bottlenecks in large-scale dataset generation and limiting parameter space exploration. I will build an Agentic AI framework following the HEPTAPOD philosophy to autonomously orchestrate DeepLenseSim workflows across three phases: (1) implementing schema-validated Pydantic tools wrapping the DeepLens class for all four model configurations, an LLM orchestration layer via OpenRouter function calling, human-in-the-loop confirmation flow, and a compatibility layer addressing pyHalo/lenstronomy/numpy version conflicts; (2) building a ParameterScanTool for automated multi-point sweeps (axion mass, halo mass, redshift), a ValidationTool for automated image quality checks, and exploration of RL-based parameter optimization; (3) comprehensive documentation, tutorial notebooks, a test suite with >80% tool function coverage, and integration with downstream DeepLense ML training pipelines via standard export formats (numpy, HDF5, FITS).

pythonmachine learningc+++2
Student: Aatmaj28
Code

Create tournaments and a player ranking system for Mankala

intermediate
KDE Community•2026Varies175h (Medium)

The project aims to develop a tournament interface for Mankala Engine, utilizing QXMPP to pair users and computerized opponents and create a leaderboard page to display rankings. The implementation would involve Qt, QML, QXMPP, and C++, as well as an algorithm to pair users randomly for tournaments and follow the ranking hierarchy until the last match to display the leaderboard. The project also enhances certain features, including QXMPP and the game experience, by addressing false positives and bugs that occur within the game.

c/c++qtqml+6
Student: Sayandeep Dutta
Code
Proposal

2D Free-Form Deformation (FFD) Layer for Synfig Studio

advanced
Synfig•2026Varies350h (Large)

Currently, Synfig artists rely on complex skeleton rigging to achieve organic deformations like squash-and-stretch or facial movements. This project introduces a 2D Free-Form Deformation (FFD) layer, allowing users to intuitively warp artwork using a manipulatable control grid (lattice) instead of bones. The implementation involves creating the core deformation math engine (upgrading from Bilinear to Catmull-Rom spline interpolation for C1 continuity), integrating the grid points with Synfig's Duckmatic UI system .

c++gtkgtkmm+2
Student: ahmedfathy0-0
Code
Proposal

Integration of SW360 and LicenseDB

intermediate
SW360•2026Varies175h (Medium)

SW360 currently imports license and obligation data through five disconnected paths with no coordination between them, meaning multiple instances can hold different obligation text for the same license with no way to detect the gap. This project makes LicenseDB the single authoritative source by implementing scheduled REST based synchronization. It covers paginated license and obligation sync, incremental daily updates via the audit log, field-level mapping that preserves SW360-specific compliance fields, read-only gating of legacy import paths, and CouchDB-first lookup for CLI attachment processing. Deliverables include JWT authentication, automated daily scheduling via ScheduleHandler, admin REST endpoints for sync control and health monitoring, encrypted credentials, circuit breaker and rate limiting, a migration guide, and test coverage.

javareactcouchdb+1
Student: Sandyp
Code
Proposal

Unsupervised Super-Resolution and Analysis of Real Lensing Images

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

Strong gravitational lensing is among the most powerful observational probes of dark matter substructure. High-resolution lensing images encode the morphological fingerprints of different dark matter models. Most available lensing images today and expected from upcoming surveys such as Euclid and LSST are ground-based and limited in resolution by atmospheric seeing. Obtaining matched high-resolution counterparts from space-based instruments like HST for every ground-based image is impractical at survey scale. This project addresses two main challenges in the proposed ML4Sci topic. First, it explores a super-resolution pipeline that does not require matched real low-resolution and high-resolution lensing observations for training. Instead, the model is trained on simulated high-resolution lensing images constructed with realistic source morphologies and survey-calibrated degradations, while remaining unsupervised with respect to real telescope HR targets. Second, it tests whether using real galaxy morphologies and limited ablations, can reduce the realism gap introduced by purely parametric Sérsic source models.

pythonmachine learningc+++2
Student: Prajwal Uday
Code

Guide website revamp

advanced
Wagtail•2026Varies350h (Large)

This project aims to revamp the Wagtail Editor Guide by addressing key limitations in versioning, localization, developer experience, and frontend performance. It introduces an automated versioning system with selective updates and redirect handling, integrates robust multilingual support using wagtail-localize with RTL compatibility, and reduces contributor friction through improved setup and realistic data fixtures. Additionally, the project modernizes the frontend by removing unnecessary dependencies, optimizing fonts, and enhancing UI/UX interactions, resulting in a faster, more maintainable, and globally accessible documentation platform.

pythonjavascriptdjango
Student: Raghad Dahi
Code
Proposal

Modernizing Mesa-Geo: PropertyLayer Refactor, Cell/Agent Decoupling & Visualization Overhaul

advanced
Project Mesa•2026Varies350h (Large)

Mesa-Geo currently suffers from three structural problems that make it impractical at realistic geographic scale: a memory bottleneck from instantiating one Python object per raster pixel, a fractured coordinate system that silently conflates three incompatible reference frames, and a broken Cell/Agent abstraction that floods the agent registry with millions of ephemeral entries. This project resolves all three problems through four focused changes: refactoring RasterLayer onto a PropertyLayer NumPy backend, decoupling Cell from mesa.Agent through a weakref identity cache, delivering a RasterCellCollection aggregation API with scipy.ndimage-powered spatial statistics, and overhauling the visualization pipeline to render rasters as a single ipyleaflet.ImageOverlay instead of millions of polygon draws. All work is aligned with Mesa 4.0's unified reactive architecture, positioning Mesa-Geo as the geospatial pillar of Mesa's next generation rather than a legacy bolt-on. Core deliverables: PropertyLayer-backed RasterLayer, decoupled Cell with three explicit coordinate properties, RasterCellCollection aggregation API, SolaraViz-compatible make_geospace_component, a geo predator-prey benchmark model, and a full Mesa-Geo 3.x migration guide. Stretch goals: H3 hexagonal grid support, a GeoSpace redesign proof-of-concept (#2585), and a Kalman filter temporal state estimation API for PropertyLayer.

pythonui/uxLLMs+4
Student: Tejasv Singh Hada
Code

Extending Clang API Notes for C++: Overload-Specific Annotations for Ordinary Methods

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between overloaded methods such as foo(int) and foo(double), so annotations are applied to all overloads with the same name rather than to a specific function. The project introduces overload-aware matching for C++ methods, allowing API Notes to target individual overloads based on their parameter types while preserving compatibility with existing notes. This enables more precise annotations and improves interoperability for real-world C++ APIs, such as Swift bindings. The core deliverable is a working and tested implementation for explicit-parameter overloads (Phase 1), including typed-vs-legacy handling and regression tests. The project then extends this to support const- and ref-qualified member functions (Phase 2), completing support for receiver-sensitive overloads.

cllvmc+++3
Student: Dominic Stöcker
Code

Improving Clang-Doc

intermediate
LLVM Compiler Infrastructure•2026$3k–$6.6k175h (Medium)

Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption is the absence of Markdown support inside documentation comments. Fenced code blocks, pipe tables, and lists currently pass through to output generators as raw text, making generated documentation unreadable for any project that uses Markdown in its comment workflow, which includes LLVM itself. This project implements a standalone Markdown parsing library that takes text and returns typed data structures, with no knowledge of comments or Clang internals. Clang-Doc is the immediate consumer, but the library is usable by any LLVM tool. It follows the same pattern as the Mustache library from GSoC 2024, with no third-party dependencies. Deliverables include the full library, Clang-Doc integration, updated HTML and Markdown generators, end-to-end lit/FileCheck tests, a libFuzzer harness, and an LLVM blog post. Stretch goal: Clang AST support for Doxygen group comments, flagged by mentors as particularly valuable.

cllvmc+++3
Student: NeilN
Code
Proposal

Set Up BookBrainz for Internationalization

intermediate
MetaBrainz Foundation Inc•2026Varies175h (Medium)

BookBrainz is currently English-only, limiting its global reach. This project integrates i18next with BookBrainz's React SSR pipeline to enable full internationalization: locale-detection middleware (Accept-Language + cookie), a language selector in the navbar, English translation JSON files, ~620 strings migrated across ~120 files, and a BookBrainz project on translations.metabrainz.org so volunteer translators can contribute immediately — with no rebuild required per translation update.

pythonjavascriptperl+8
Student: Garv Thakre
Code
Proposal

Enhancing the Kirigami Developer Experience

intermediate
KDE Community•2026Varies175h (Medium)

This project focuses on improving the developer experience around the Kirigami framework by making the development workflow more connected and efficient. Kirigami already provides well-structured documentation and examples, but these resources are spread across different places, making it harder to explore them interactively and move smoothly from learning to practical hands-on. To address this, I will enhance Kirigami Workbench and integrate it with KAppTemplate. The project introduces an interactive gallery of examples with live previews and editable code, along with a plugin-based system so new examples can be easily added and explored within a single environment. Developers will also be able to generate ready-to-use application projects using KAppTemplate, with selected examples as the starting point, along with added Python support for developing Kirigami applications using PySide6/PyQt6 within Workbench. The main deliverables include the example gallery with search and filtering, plugin support, project generation using KAppTemplate, Python support, and multi-tab functionality for working with multiple files. Overall, this project makes working with Kirigami smoother and more connected, bringing everything into one place.

c/c++qtqml+6
Student: Shubham Shinde
Code
Proposal

Enhancing Usability of the Eventyay Badge Creator

advanced
FOSSASIA•2026Varies350h (Large)

This project would make the Eventyay badge creator much more user-friendly and also add badge printing in the event check-in workflow itself. Right now, event organizers have to separately go to a different page in order to download badge PDFs before they can even print them out, adding friction during busy events and slowing down the check-in process. This project will integrate badge printing into the webcheckin interface so event staff can print attendee badges immediately after ticket redemption. There are also ticket types, a modal pop-up for the badge layout creations workflow (optional role-based template badges: speaker /attendee/ volunteer/ exhibitor), and improved badge editor experience. Implementation will make a wrapper around existing Django-based badge plugin and Vue. jsWebCheckin application used in Eventyay. Its exact features will include usage of existing badge download APIs, refactored frontend integrations for printing, optional config settings for automatic printing and updated documentation and tests. Deliverables badges design flow; embedded on-line badge printing for check-in app; usability improvements in badge editor;API documentation: performance enhancement (caching, asynchronous generation handling); updated developer and user documentations. This will save a lot of time at check-in and provide a better management experience to the organizers using Eventyay.

pythonjavascriptandroid+7
Student: Makwana Rachit Arvindbhai
Code
Proposal

New Command Processing Infrastructure

intermediate
Apache Software Foundation•2026$3k–$6.6k175h (Medium)

Apache Fineract is open-source banking software used by institutions around the world to serve people who don't have access to traditional banks. Every time someone opens an account, creates a loan, or uploads a document, the system has to read the incoming data, validate it, and save it. The current code that does this was written about twenty years ago, the data arrives as plain text, and the system manually picks apart each field by hand. This causes silent bugs, makes the code hard to change, and produces thousands of lines of repetitive plumbing. The Fineract community has already built a modern replacement that uses strongly-typed data objects, so data is automatically structured and validated the moment it arrives. The new system is in production for 13 features; around 57 features still use the old approach. My GSoC project is to move 5–7 of those remaining features onto the new system, one feature at a time, strictly following the migration guide the team has already written. Proposed features (subject to mentor confirmation): Holidays, Account Number Format, Codes / CodeValues, Office, Fund, and Calendar. For each feature, I will design new typed data classes, rewrite the related handler code, simplify the business logic to accept typed inputs, replace hand-written validation with built-in checks, and make sure all existing tests still pass. Where test coverage is thin, I will add new automated tests in line with the community's quality direction. This work reduces long-standing technical debt and makes future development faster and safer in a system that real banks depend on every day.

pythonjavascriptjava+7
Student: Nidhi Bhawari
Code
Proposal
Showing 73 - 96 of 11996 Projects
23456
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal