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

Vulkan video filters: deinterlace, adjust and others

intermediate
VideoLAN•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)

After video decoding in VLC it might be that the user wants to use a specific filter like deinterlace and/or adjust and/or other filters that run on the GPU before the frame gets displayed. Vulkan branch now misses filters support and many GPU-accelerated filters in VLC that some of them currently existed in OpenGL pipeline (deinterlace) not yet available for the Vulkan pipeline. And other filters are not implemented in Vulkan and OpenGL (adjust). This project will introduce the Vulkan-based filtering abstraction and implement some filters such as deinterlace and adjust-style filters (brightness, contrast, saturation, gamma) using Vulkan shaders.

copenglc+++10
Student: Abderhman Gamal
Code
Proposal

QA of Reset of Core Systems

intermediate
Open Robotics•2026Varies175h (Medium)

Self Introduction: My name is Yimo Wang.I am a Master’s candidate in Software Engineering at Dalian University of Technology, expected to graduate in June 2027. I am an active contributor to the Gazebo simulator project, with extensive experience in C/C++, ROS 2, and related development tools such as CMake and GDB. Brief Plan of proposal: First, we should know how to design the basic process of a single plugin test. It should be as lists: 1. start simulation and collect state before calling reset 2. call reset and step forward 3. verify if old states of the plugin are reset 4. step forward again to verify if works well after calling reset Second, we should extract functions from every step to build a standard test suite. Finally, we use the standard test suite to build integration tests for every single plugin in the core system. Then run tests and audit their behaviors. After auditing, we should fix plugins that lead to state leaks after calling reset. Adding the Reset function explicitly and mounting ISystemReset is a good option. After the fixes are completed, we can then incorporate tests into the CI pipeline to prevent regressions.

pythonc/c++ros+5
Student: Oscmoar07
Code
Proposal

OWASP FinBot Guardrail Framework and Realistic Agentic Security Scenarios

intermediate
OWASP Foundation•2026Varies175h (Medium)

This project extends OWASP FinBot by implementing a guardrail and detection framework for agent based AI systems. The system will monitor tool usage, detect unsafe agent behavior, generate security events, and enable defense focused CTF scenarios aligned with the OWASP Agentic Top 10.

pythonjavascriptjava+10
Student: Nitin Awari
Code
Proposal

X.509 Certificate Generator Templates

intermediate
OpenWISP•2026Varies175h (Medium)

Currently, OpenWISP restricts automated X.509 certificate generation exclusively to OpenVPN clients, which limits administrators who need general-purpose certificates for web services, internal APIs, or device authentication. This project introduces a new standalone certificate template type that leverages the existing infrastructure to generate certificates using a selected Certificate Authority and a reusable blueprint. Key deliverables include full certificate lifecycle management, configuration template variable integration, admin UI and REST API updates, comprehensive automated testing, and detailed documentation

pythonjavascriptdjango+5
Student: Sarthak_Tyagi
Code
Proposal

AI-Powered Content Generation Assistant for Drupal

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

Drupal's AI Content Strategy module does a great job telling editors what to write, but the moment it hands off, editors are left staring at a blank field with no actual help getting words on the page. This project builds a content generation assistant that sits directly inside Drupal field widgets, letting editors prompt an AI model and insert the result without ever leaving the editing interface. The module will be built around a clean plugin architecture that supports OpenAI GPT, Anthropic Claude, Hugging Face, and Google Gemini as interchangeable providers, with a React-based prompt dialog giving editors control over tone, length, and style. A REST endpoint will bridge the frontend widget to the backend provider system, and the module will include generation history tracking, rate limiting, and cost cap controls for site administrators. By the end of GSoC, the project will ship as a fully documented, publicly released Drupal module that closes the gap between strategic content recommendations and actual content creation.

mysqljavascripthtml+2
Student: Nik07op
Code
Proposal

pgmoneta: Model Context Server implementation

intermediate
PostgreSQL•2026Varies175h (Medium)

The motivation behind this project is to extend and introduce a fully functional MCP server for pgmoneta. To achieve this ultimate goal, we have identified a set of subgoals that will transform the current implementation into a production ready system: Introduce Non-Blocking I/O for Intensive I/O Operations (e.g Backup). Architectural Abstraction refactoring via the Rig Framework. Production-Level Security & Authentication. Knowledge Retrieval via MCP Resources. Testing and Documentation

cpostgresqlperl+8
Student: Ahmed Kamal AbdElrasol
Code
Proposal

Surfer Memory and Wide Array Support

advanced
Free and Open Source Silicon Foundation•2026Varies350h (Large)

This proposal focuses on enhancing the Surfer waveform viewer by adding support for memory and wide array visualization. Current waveform views are effective for scalar signals but become inefficient when dealing with large arrays or memory structures. This project introduces a structured table based visualization for memory contents along with intelligent change highlighting across timestamps. The implementation will improve debugging efficiency by allowing users to inspect memory elements individually rather than scanning entire waveforms. The solution integrates seamlessly with Surfer existing architecture and maintains performance for large datasets.

pythonjavascriptfpga+11
Student: Kutikuppala Deekshita
Code
Proposal

Add the EoP Game to the card browser

intermediate
OWASP Foundation•2026Varies175h (Medium)

Currently, the EoP deck is not browsable or accessible through Cornucopia's API, blocking integration with OWASP Threat Dragon. This project adds a fully browsable Elevation of Privilege (EoP) deck to OWASP Cornucopia and exposes EoP cards through the existing API, enabling Threat Dragon integration. The implementation follows the Companion Edition scaffolding as a reference, which I already implemented in PR #2528 (https://github.com/OWASP/cornucopia/pull/2528). Deliverables include: data scaffolding for all 78 EoP cards across 6 suits, browsable deck UI with full card endpoints, API endpoints for EoP language and CRE mappings, a "Need more info?" link on copi cards linking to their corresponding cornucopia.owasp.org pages, and a maintainability refactor of the card browser — moving suit colors and per-card image data into YAML config files and introducing per-deck layout components, so adding any future deck requires only config and a new component with no changes to existing templates. The EoP game is licensed under CC-BY-3.0.

pythonjavascriptjava+10
Student: Ayman Algamal
Code
Proposal

Ruby Vulnerability Warnings on RubyGems

intermediate
Ruby•2026Varies175h (Medium)

Developers using Ruby gems have no official way to know when a gem they depend on has a known security vulnerability. This project integrates vulnerability warnings into RubyGems.org by syncing the rubysec advisory database, implementing version-range matching via Gem::Requirement, and surfacing warnings on gem detail pages, search results, and a new public API endpoint — all with independent implementation to respect GPL licensing boundaries.

rubycjava+3
Student: Harinish Sabapathi
Code
Proposal

Jitsi Videobridge JavaScript client

intermediate
Jitsi•2026Varies175h (Medium)

The objective of this project is to develop jvb-js, a WebRTC client library for building real-time audio and video applications with Jitsi Videobridge, a Selective Forwarding Unit (SFU).

javascriptjavaxmpp+5
Student: Hugo Lavernhe
Code
Proposal

Unified SBOM Management via RDF Database Abstraction - Maira Papadopoulou

advanced
Open Technologies Alliance - GFOSS•2026Varies350h (Large)

This project addresses the growing challenge of managing Software Bill of Materials (SBOM) data at scale. While SBOMs in the SPDX format are essential for software supply chain security, current file-based approaches (e.g., JSON or RDF/XML) are not well-suited for complex querying, or large-scale analysis. To overcome these limitations, this project proposes a set of tools that leverage RDF triplestores for storing and managing SBOM data. SPDX documents will be parsed into structured Python objects, transformed into RDF triples, and stored using a unified triplestore abstraction layer. This approach enables powerful querying through SPARQL while remaining database-agnostic, supporting multiple backends such as Apache Jena, GraphDB, Blazegraph, AllegroGraph, and Oxigraph. The project will deliver a complete pipeline for SBOM ingestion, storage, and reconstruction. Key deliverables include: (1) a CLI-based ingestion tool for importing SPDX documents into RDF databases, (2) an export tool for reconstructing valid SPDX documents from queried data, (3) management utilities for CRUD operations on SBOM data, (4) a comprehensive test suite to ensure correctness across multiple backends, and (5) detailed documentation for both users and developers. This approach transforms SBOM data from static documents into a structured, queryable knowledge graph, enabling more efficient retrieval and analysis across different systems and backends.

pythonmysqljava+7
Student: Maira Papadopoulou
Code

Add infrastructure to handle the "Drop" trait

beginner
GNU Compiler Collection (GCC)•2026Varies90h (Small)

gccrs still lacks support for Rust’s Drop trait, which is a core part of Rust’s resource management model. Without it, values that require cleanup cannot be handled correctly at scope exit, which makes gccrs incomplete with respect to important Rust semantics. This project proposes an incremental implementation of Drop support in gccrs, starting from a narrow and testable subset rather than attempting full drop elaboration at once. The first stage focuses on scope-exit destructor insertion for simple non-generic local variables using existing backend cleanup machinery. From there, the implementation will be extended to support multiple locals, correct reverse drop order (LIFO), and, if feasible, initial nested-scope cleanup. More advanced cases such as moved values, temporaries, partially initialized values, and generic Drop will be treated as later-stage or stretch work. The main deliverables are: an initial implementation of scope-exit Drop support for a restricted subset of local variables, support for correct LIFO drop ordering, regression tests covering the supported behavior, and documentation describing the implementation approach, supported subset, and current limitations.

cc++openmp+3
Student: Janet Chien
Code
Proposal

Extending Neutralinojs Native API with Cross-Platform System-Level Capabilities

advanced
Neutralinojs•2026Varies350h (Large)

This project aims to enhance the Neutralinojs framework by introducing a comprehensive set of cross-platform native APIs that expose essential system-level functionalities currently missing from the platform. Developers currently rely on platform-specific workarounds, shell commands, or external tools to access critical features such as hardware information, system configuration, filesystem utilities, and global OS integrations. It increases complexity, reduces portability, and negatively impacts developer experience. To address this, the project proposes implementing new APIs across five major namespaces: computer, window, app, filesystem, and os. The implementation will strictly be following Neutralinojs principles: minimal dependencies, high performance, strong security, and full cross-platform compatibility across Windows, Linux, and macOS.

cjavascriptnode.js+2
Student: Prasun Baranwal
Code

Build a cybersecurity guardian that protects a person’s digital life in real time

intermediate
OWASP Foundation•2026Varies175h (Medium)

This project aims to evolve the BLT-Vanish existing privacy management platform into a proactive, real-time identity defense system. While the current platform is effective at privacy management, it lacks the live features necessary to combat modern threats, such as AI-driven phishing detection, automated credential hygiene, and a unified way to correlate suspicious logins. To solve this, I plan to introduce the Universal Identity Shield, built on a hybrid local-first and edge-processing architecture. This system will provide low-latency, explainable risk scoring and actionable guidance through three key phases: developing a foundational risk engine, implementing core security workflows like dark web monitoring and guided password rotation, and hardening the production environment using Flutter and Python-based Cloudflare Workers. The project will ultimately deliver a comprehensive suite of tools, including a phishing detection engine, a zero-plaintext encrypted vault, and an anomaly correlation system, all backed by full documentation and handover materials.

pythonjavascriptjava+10
Student: Ananya19
Code

Porting OpenPrinting to Zephyr

advanced
The Linux Foundation•2026Varies350h (Large)

This project focuses on porting the CUPS architecture and OpenPrinting tools to the Zephyr RTOS, building on prior work to enable reliable printing on resource constrained, low power hardware. The effort includes fully migrating libcups and the PAPPL framework while ensuring stable handling of IPP messages and configurations. It also aims to improve DNS SD networking and address performance bottlenecks in large file processing, such as limitations in ippFileRead, alongside establishing IPP over USB communication and upstreaming custom modifications into official Zephyr repositories. Ultimately, the project seeks to optimize performance and deliver a fully functional, energy efficient embedded print server.

cpythonmysql+7
Student: nomkar24
Code
Proposal

Databus Python Client: Manifest-Driven Reproducible Workflow Orchestration

intermediate
DBpedia•2026Varies175h (Medium)

The DBpedia Databus Python Client currently supports downloading, deploying, and deleting datasets but lacks reproducibility, workflow orchestration, and format interoperability. This project extends the client with three tightly integrated features: First, a Format and Mapping Conversion Layer (Layers 2 and 3 of the Java client pipeline) that enables on-the-fly conversion between RDF triples, RDF quads, and CSV/TSV formats using rdflib — bringing the Python client to feature parity with the Java Databus Client for the first time. Second, a structured Run Manifest System that records every operation as a fixed-format JSON-LD file using the DataID vocabulary. Manifests support replay, summary, and structured error capture — making any Databus operation fully reproducible from a single file. Third, a declarative Workflow Engine that executes multi-step pipelines defined as YAML files, with dynamic step chaining, per-step error recovery (fail, continue, retry), and automatic manifest generation for every run. Deliverables include a working --convert-format flag with 14 round-trip tests, --manifest flag on all three existing commands with manifest replay and summary commands, a databusclient workflow run command with step chaining and error recovery, five tested real-world example workflows, and full documentation — all fully backward compatible.

javascalardf+7
Student: Dhanashree Petare
Code

Interactive User Interfaces With Vue.js — Submitty

intermediate
Submitty•2026Varies175h (Medium)

Submitty's frontend relies on server-rendered Twig templates and jQuery for interactivity, leading to fragmented, hard-to-maintain interfaces. This project migrates Submitty's most critical pages - the TA grading interface, discussion forum, office hours queue, and rainbow grades customization to modular, reusable Vue.js components backed by clean PHP JSON APIs and centralized Pinia state management. The migration follows a progressive enhancement strategy using the Mount Container Pattern, allowing Vue components to coexist with legacy code at every stage, ensuring zero disruption to active users mid-semester. Deliverables include a reusable Vue component library, full reactive migration of the discussion forum and TA grading interface, a Pinia and Axios powered state and API layer, comprehensive unit and E2E tests, and a developer migration guide for future contributors. A proof of concept PR migrating the TA grading score box to Vue.js has already been submitted, validating the end-to-end approach before the program begins.

pythonc++databases+5
Student: JndlAnsh
Code
Proposal

Migrating rust-analyzer assists to SyntaxEditor

intermediate
The Rust Foundation•2026Varies175h (Medium)

This project aims to eliminate all usage of legacy mutable syntax APIs, incrementally update rowan and introduce necessary changes to RA, and then once all the new API's and changes to SyntaxEditor are fixed, we will move towards optimizing the implementation to make sure we are efficient Key objectives: 1. Migrate all remaining usages of mutable APIs (ted, make, clone_for_update). 2. Incremental rowan redesign to support: 1. trivia embedded in tokens 2. slot-based structure 3. SyntaxFactory generated from rowan grammar 4. Mutable API in accordance to named slots. 3. Evolve SyntaxEditor to operate new rowan. 4. Make rowan efficient.

pythonrust
Student: Shourya Sharma
Code
Proposal

Refactoring Synaptic Behavior in HNN-Core

intermediate
INCF•2026Varies175h (Medium)

This project focuses on improving the computational efficiency and biological realism of synaptic modeling in HNN-Core by refactoring how synapses are placed, simulated, and recorded within neuron models. Currently, synapses are instantiated at fixed locations across neuronal sections, including inactive ones, leading to unnecessary computational overhead and reduced clarity in simulation outputs. The proposed approach introduces parameterized synapse placement, ensuring that synapses are only created at locations where neurons receive thalamic or cortical input. The refactor will also restrict synaptic current recording to active synapses, reducing memory usage and improving interpretability of results. Additional enhancements include updating existing network models, ensuring backward compatibility, and developing validation strategies to maintain numerical and biophysical consistency. To further improve usability, the project will incorporate visualization tools for analyzing synaptic currents and placement patterns. Time permitting, biologically realistic variability in synapse positioning will be introduced to better reflect neural heterogeneity. While this work focuses on synaptic modeling, my recent contributions to HNN-Core have also involved improving testing infrastructure and code reliability, providing additional insight into maintaining correctness and stability in scientific simulation software. The outcome of this project will be a more efficient, interpretable, and scientifically robust synaptic modeling framework within HNN-Core.

pythonjavac+++7
Student: Satvik Saluja
Code
Proposal

MCP for OGC APIs — Developing Model Context Protocols for the Suite of OGC APIs

advanced
52°North Spatial Information Research GmbH•2026Varies350h (Large)

OGC APIs — Features, Records, EDR, and Processes — are powerful but inaccessible to non-developers. This project builds a formal MCP mapping specification that translates OGC API operations into structured tools any LLM can use, enabling urban planners and researchers to query geospatial data and chain complex workflows using plain English. Deliverables: a language-agnostic JSON mapping spec covering all four OGC API types, a Python reference implementation, and a browser-native showcase requiring no GIS expertise.

javascriptandroidjava+2
Student: Pranav Angrish
Code
Proposal

B0Bot Agentic AI Framework with LangGraph and Multi-turn Dialogue

intermediate
C2SI•2026Varies175h (Medium)

B0Bot is a Flask-based CyberSecurity News API powered by Pinecone and HuggingFace, but all logic lives in a monolithic NewsService with no caching, no agents, and no conversation state. This project replaces it with a LangGraph multi-agent system (ScraperAgent, ResponderAgent, AnalyzerAgent, NotificationAgent) orchestrated by a PlannerAgent, adds Redis TTL caching, multi-turn dialogue, CDC via RSS for incremental Pinecone updates, email subscriptions, and full Docker-based deployment with GitHub Actions CI/CD. I have discussed the architecture and agent design directly with mentor Hardik Jindal and incorporated his feedback into this proposal.

pythonjavago+2
Student: Vishak Baddur Sadanand
Code
Proposal

pgmoneta: WAL & MCP

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

pgmoneta is an open-source tool that offers a solution for PostgreSQL backup and recovery. This project is a continuation of the 2025 GSoC project on pgmoneta-walfilter, which has been enhanced to include more advanced rules such as LSN, timestamp, relation, RMGR, and user rules; an interactive mode that has been improved to include a unified search feature and rule generation; a version dispatch feature that allows PostgreSQL 14-19 support; and WAL-aware commands integrated into a Rust-based MCP server to allow AI-driven analysis and recovery, which improves visibility and control of WAL, allowing for more accurate recovery scenarios and reducing the workload of a database administrator, making it a more powerful and intelligent tool for PostgreSQL backup and recovery.

cpostgresqlperl+8
Student: Sara Nabih
Code
Proposal

VSE: Strip Transition Handles

intermediate
Blender Foundation•2026Varies175h (Medium)

Currently transitions in VSE (Blender's video editor) have usability issues, as transitions can't be on the same channel as the input strips, and there aren't dedicated transitions for audio strips. This project aims to address these main usability issues. The project adds handles to transitions (eg. crossfades) in the VSE, allowing users to move the transitions and change their length. When adding transitions, they get a default length. A right-click context menu - when clicking between strips - for adding transitions is added. Adjustable crossfades for sound strips are added.

cpythonopengl+3
Student: il4n
Code
Proposal

Pwndbg: Improve Android Debugging Support.

intermediate
Python Software Foundation•2026Varies175h (Medium)

Pwndbg delivers a powerful debugging experience on traditional Linux systems, but its support for Android environments remains limited. This is largely due to fundamental differences between GNU libc and Android’s Bionic, as well as the lack of tooling for Android-specific components such as Binder. As a result, many existing features either do not work as expected or provide limited insight when analyzing Android binaries. This project aims to address these limitations by introducing structured and practical support for Android within Pwndbg. It will extend existing features to correctly handle Bionic internals, particularly in memory inspection and heap analysis, and improve Binder support by enabling meaningful userspace inspection. Additionally, the project will refine internal abstractions to ensure consistent behavior across LLDB and GDB.

pythonmercurialjavascript+3
Student: José Guilherme
Code
Proposal
Showing 1081 - 1104 of 11996 Projects
4445464748
Proposal
Proposal
Proposal
Proposal