Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
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.
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.
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.
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
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.
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
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.