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
13453 Projects Found
Sort by

AI-Powered Toxic Content and Spam Detection for Drupal

intermediate
Drupal Association•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)

Community-driven Drupal sites currently rely on reactive, manual moderation for spam and toxic content, which is exhausting and difficult to scale. This project introduces a proactive, real-time defense system by building a fully integrated AI Content Moderation module. The solution utilizes a decoupled ContentModerator service that intercepts form submissions on the client side using debounced JavaScript, providing users with instant, WCAG-compliant inline warnings before toxic data ever hits the database. On the backend, it employs a highly performant hybrid approach, checking local administrative keyword lists before securely querying external NLP models (such as Hugging Face) via Drupal's core HTTP client. Deliverables include a production-ready module featuring an intuitive Admin UI for AI provider and threshold configuration, bulletproof server-side validation fallbacks, and comprehensive site builder documentation.

mysqljavascripthtml+2
Student: Talha Asif
Code
Proposal

Allocation-Free GPU Adaptive Mesh Refinement for P4estMesh in Trixi.jl.

advanced
The Julia Language•2026Varies350h (Large)

My main goal this summer is to make Adaptive Mesh Refinement (AMR) fast and efficient for P4estMesh on GPUs within Trixi.jl. Right now, whenever the mesh adapts dynamically, it triggers repeated memory allocations on the device. This creates a severe host-device synchronization bottleneck that kills performance, despite the excellent hardware support we have via KernelAbstractions.jl. To solve this, I will build an allocation-free memory manager. By implementing a multi-pool arena specifically designed to match Trixi's Struct-of-Arrays (SoA) layout, I aim to eliminate these driver-level stalls. My final deliverables include a fully functional, type-stable GPU AMR pipeline and comprehensive performance benchmarks across both NVIDIA and AMD hardware

cjavascriptc+++12
Student: Shahu Karale
Code

Learner Facing QTI Interactions for Kolibri

intermediate
Learning Equality•2026Varies175h (Medium)

Kolibri's QTI 3.0 viewer currently renders only Multiple Choice and Text Entry, leaving the majority of the specification's interaction types unsupported. This project extends the plugin to implement six additional types: Inline Choice, Match, Order, True/False, Gap Match, and Fill-in-the-Blank — each requiring careful integration with the existing SafeHTML rendering registry and QTIVariable response system. The core technical challenges are accessibility and interaction fidelity: drag-and-drop interactions (Order and Gap Match) require a fully keyboard-native select-to-place model as the primary interaction, with SortableJS-based drag as the pointer enhancement. Match Interaction requires a directed-pair association model rendered as an accessible grid. All six types must support RTL languages, touch devices, and low-end hardware — not as retrofits, but as first-class constraints from the start.

pythonjavascriptdjango+1
Student: Habiba Ayman
Code
Proposal

Rosetta: Python wrappers for Bioconductor packages via rpy2

beginner
R project for statistical computing•2026Varies90h (Small)

Problem: R remains the gold standard in bioinformatics thanks to Bioconductor. However, many data scientists prefer Python for machine learning and building production. Currently, bridging tools such as rpy2 suffer a lot from stability issues. For instance, ABI symbolic linking errors and complex S4 object mapping failures, obstructing complete integration with essential tools like DESeq2. Solution: This project aims to enhance the Rosetta library by implementing a robust three-tier API architecture. This architecture includes an easy-to-use high-level Python interface, a fine-grained control layer for advanced users, and a subprocess-based fallback mechanism to prevent core crashes. I will focus on addressing deep interoperability challenges, including S4 method distribution and cross-language type conversion. Deliverables: 1.A stable, production-ready DESeq2 and edgeR Python wrapper library. 2.A three-tier API design ensuring 100% statistical consistency with native R output. 3.During periods of high load, the subroutine falls back to the backend to ensure system stability. 4.Comprehensive documentation and a Pytest-based validation suite ensure a reproducible experimental environment.

cc++r+4
Student: Catherine Chung
Code

ImageJ Active Segmentation platform: Parallel Engine for ASP/IJ

advanced
INCF•2026Varies350h (Large)

This project accelerates the convolution core of the Active Segmentation Plugin (ASP) in ImageJ by offloading its most compute-intensive pixel operations to parallel hardware using TornadoVM. The goal is to achieve significant speedups without altering existing functionality or behavior. The approach focuses on identifying CPU bottlenecks, converting them into accelerator-friendly kernels, and executing them through a reusable TornadoVM pipeline. A strict correctness-first methodology ensures all accelerated outputs match the CPU reference in terms of boundary handling and numerical accuracy before any performance gains are considered. By integrating a robust, reusable parallel execution layer with safe CPU fallback, this work transforms ASP’s performance while preserving its reliability—laying the foundation for scalable acceleration across multiple filters and larger image-processing workflows.

pythonjavac+++7
Student: Pakhi Awasthi
Code
Proposal

Case split plugin

intermediate
Haskell.org•2026Varies175h (Medium)

The goal of this proposal is to extend HLS with a new plugin, the case split plugin, which provides a new code action (or possibly more of them) for completing the case ⟨expression⟩ of part of a case expression with the properly formatted list of alternatives, which is implied by the type of ⟨expression⟩. GHC API will be used to detect the cases missing from a (totally or partially) incomplete case expression, and to insert the missing cases in the AST, ghc-exactprint will be used for pretty-printing such missing cases in the text file.

haskellghccabal+3
Student: Aster89
Code
Proposal

Kubernetes Operator for Automated Policy-Based Checkpointing

intermediate
CRIU•2026Varies175h (Medium)

The Checkpoint-Restore Operator manages checkpoint retention well but has no way to create checkpoints automatically. This project adds a new CheckpointSchedule CRD and controller that triggers checkpoint creation through four mechanisms: cron-based time schedules, CPU/memory resource thresholds, Kubernetes cluster events (node drain, pod eviction, preemption), and pod annotations for application-level signaling. All triggers call the existing Kubelet Checkpoint API via the Kubernetes API server proxy. Deliverables include the CheckpointSchedule CRD, a CheckpointCreator that calls the Kubelet API, four independent trigger subsystems, a TriggerManager to coordinate them, a full controller-runtime reconciler, RBAC updates, unit and BATS integration tests, and sample configuration. Together with the existing retention policies, this turns the operator into a complete checkpoint lifecycle manager — admins declare both when checkpoints are created and how long they are kept, with no custom scripting required.

clinuxassembly+3
Student: Rupam-It
Code
Proposal

Laureen Caliman Vocab Style Puzzles to GNOME Crosswords

intermediate
GNOME Foundation•2026Varies175h (Medium)

Created in the early 2020’s, GNOME Crosswords became a well-liked application powered by the libipuz C library. While robust, it does not have customizable vocabulary-style puzzles. However, the implementation of a grid-generating algorithm would provide GNOME Crosswords with the ability to diversify their consumer base to even more educators. The primary focus will be to introduce a vocab-style puzzle generator to the GNOME system. The algorithms must be able to interlock words on a 2D grid tightly without breaking rules, sort inputs by length, seed the board dynamically, recursively match words to find orthogonal points to sew words together, check the constraints per surrounding cells, and score upon a placement with the failsafe to take a step back and rearrange the former word suitably. Doing so requires creating classes using GObject and GLib. A full-stack approach must accommodate for validating vocab puzzles using libipuz and Glib in the backend, and also provide an input editor for users which render a grid focused on quality using GTK4, GObject, and libadwaita in the frontend.

cpythonjavascript+4
Student: Laureen Caliman
Code
Proposal

Generalized graphical data rendering representation

intermediate
Graphite•2026Varies175h (Medium)

This project refactors Graphite to create a more generalized graphic representation of paints. It introduces dedicated Gradient and Pattern nodes, as well as updated Fill and Stroke nodes that can consume generalized graphic sources, not just the current fill and color types. The project also enables the standalone rendering of colors, gradients, patterns, and other compatible graphics as ordinary layers. The implementation will update Graphite's graphics, nodes, and Vello/SVG renderers to support gradient strokes and pattern fills. Additionally, SVG import will be supported for the MVP subset of these features. Stretch goals include broader gradient support, such as focal points, conic gradients, and gradients along strokes.

machine learningrustvulkan+2
Student: Yohei Yamasaki
Code
Proposal

Reducing pg stat statements LWLock Contention

advanced
PostgreSQL•2026Varies350h (Large)

pg_stat_statements tracks query statistics across a PostgreSQL cluster, but its single-LWLock architecture creates a scalability bottleneck under high unique-query-rate workloads. When pg_stat_statements.max is undersized, deallocation and reset operations hold an exclusive lock while performing expensive operations (O(n log n) sort, full hash table iteration), blocking every backend on the server. My benchmarks on PG 19devel show 90-100% of active backends blocked on the pgss LWLock during deallocation churn. This project proposes a multi-part fix: (1) a pending-entry queue to avoid blocking on new entry insertion, (2) a restructured deallocation critical section that moves the sort outside the exclusive lock, (3) exploration of lock separation between structural changes and counter updates, and (4) an optimized reset path. Deliverables include a repeatable benchmark suite, patches for each optimization formatted for pgsql-hackers review, before/after performance measurements, and documentation.

cpostgresqlperl+8
Student: hoangquan456
Code
Proposal

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

advanced
OpenVINO Toolkit•2026Varies350h (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
Showing 145 - 168 of 13453 Projects
56789
Proposal
Proposal
Proposal
Proposal
Proposal