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

Commons Numbers Library for Complex Linear Algebra

advanced
Apache Software Foundation•2022Varies

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)

The existing Commons Numbers library for complex types uses collections of complex object instances that incur Java object allocation overhead and is inefficient for iteration and operations on large complex data sets. There are several third party Java libraries for complex math that each have their advantages and disadvantages, but Java developers currently have no single API for Complex operations that can use these libraries at runtime without rewriting their applications This project would provide Java developers with a single Complex API with abstractions that allow for efficient data structures (such as primitive arrays and value types - as proposed by Java Project Valhalla), use of Java 8 language features (Lambdas/Streams) and a Service Provider Interface (SPI) to integrate with existing (JTransforms, JBLAS, EJML) and future third party libraries (Java 17 Vector API, jcuda, aparapi) The project deliverables would include interfaces to represent complex scalar, vector, matrix types and functional interfaces for complex unary and binary operators & functions. The existing methods in Commons Numbers would be refactored as static functions for use as Lambdas with the new API. The JTransforms library will be integrated for supporting operations such as fast Fourier and Discrete Cosine transforms. Optionally, an implementation using Java 17 vector API would be provided for basic operations on complex vectors and matrices. Performance benchmarks comparing different implementations would be published. The deliverables will include complete Pull Requests meeting all Apache Commons Numbers project requirements

pythonjavascriptjava+7
Student: Sumanth Sulur Rajkumar
Code
Proposal

Interfacing PODIO to Julia

advanced
CERN-HSF•2022Varies350h (Large)

Currently, two major languages are used in high-energy physics (HEP): C++ for numerically intensive code, where execution speed is critical, and Python for interactivity and simplicity of development (frequently used as 'glue' between high-performance code modules). Julia has recently sparked increased attention as a potential language for HEP. This could provide Python's convenient features while maintaining C++'s ideal computational efficiency. In order to continue this investigation, this project will interface the data model library PODIO with Julia. This will allow you to read existing data files into a Julia program. This project seeks to use the same YAML-syntax to auto-generate Julia code for the end user to be utilized in HEP, as well as to do performance testing to compare the language interfaces for C++ and Julia. General Plan PODIO can already : Read YAML files and validate and parse them to extract necessary information like data members, relations and vector members of components and form MemberVariable objects from that information, forming a object dictionary to be used by the jinja2 template engine (using templates for C++) to generate C++ code. Our Plan: Build a prototype without code generation to test whether the current info passed to the jinja2 template Engine by the ClassGenerator class is sufficient, Accordingly adding the pre-processing logic required to the ClassGenerator class create new templates and dictionaries for jinja2 to generate Julia code. Running tests on the Julia code and refactoring generator code. Benchmarking and Documentation.

pythonc/c++machine learning+6
Student: Soumil Baldota
Code
Proposal

OrgExplorer GitHub Organization Analytics Dashboard

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

When I first tried exploring open-source organizations on GitHub, I kept running into the same problem. GitHub shows great details for each repository, but almost nothing that helps you understand an organization as a whole. I had to open repo after repo just to figure out which projects were active, which languages were common, and who was actually contributing. It felt slow, manual, and frustrating. That experience led me to build OrgExplorer. OrgExplorer is a fully client-side web app that turns raw data from the GitHub REST API into clear, organization-level insights. There’s no backend, no login, and no setup. You simply enter one or more organization names and, within seconds, you can see language distribution, repository health, contributor coverage, governance risks, and activity trends. Everything is cached locally so the app feels fast and doesn’t waste API requests. Behind the scenes, OrgExplorer merges repositories and contributors from multiple organizations into a single data model. From that, it highlights practical signals like bus factor risk, cross-repo contributor coverage, dead issues, zombie pull requests, and how activity changes over time. By the end of GSoC, OrgExplorer will support multi-organization analysis, an interactive contributor–repository network graph, repository health classification, governance audits, activity trend charts, exportable reports, deep-linked views, and offline support as a Progressive Web App. Smart caching ensures it stays within GitHub’s rate limits, with optional token support for larger explorations.

pythonjavascriptswift+8
Student: Ritik Roshan Yadav
Code
Proposal

AI-Generated Note Graphs

advanced
Joplin•2026Varies350h (Large)

Joplin users accumulate hundreds of notes over time, but existing graph plugins only visualize explicit links (:/noteId) and shared tags, leaving semantically related yet unlinked notes disconnected. This project introduces an AI-powered Joplin plugin that uncovers these hidden relationships using text embeddings as the primary mechanism, with optional LLM-based enrichment for labeling and categorization. The default embedding provider is Transformers.js, enabling fully local, zero-setup inference with no external dependencies, while advanced users can opt into Ollama, Google Gemini, OpenAI, or compatible APIs. The system combines explicit links, tag relationships, and embedding-based semantic similarity into a unified graph, ensuring comprehensive note connectivity. The plugin renders this enriched structure as an interactive graph using Cytoscape.js with the fCoSE layout, where node size reflects centrality, node color represents Louvain-detected communities, and edge styles distinguish relationship types (solid for links, dotted for tags, dashed for semantic connections). It includes features such as click-to-navigate, focus mode, filtering, and export to PNG/SVG/JSON. A SQLite-based cache stores embeddings for incremental updates, ensuring scalability and performance, while optional Pass B LLM enrichment adds human-readable relationship labels and categories. The final deliverable is a production-ready .jpl plugin with secure API key handling, provider abstraction, and a comprehensive test suite including deterministic validation of AI outputs.

reactnode.jsreact native+5
Student: yugalkaushik
Code
Proposal

Kthena Router Benchmark (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>Kthena Router is the LLM routing component in the Volcano/Kthena project, responsible for forwarding inference requests to in-cluster and (soon) third-party model backends. As Kthena gradually matures, the community needs a reproducible benchmark to understand the router's performance characteristics (throughput, latency, tail latency, resource usage) under realistic LLM traffic patterns, and to detect regressions across releases. This project asks the mentee to design and implement a benchmark framework for Kthena Router, produce a complete report. Where the benchmark surfaces clear bottlenecks or inefficiencies, the mentee will also work with maintainers to land code-level optimizations upstream.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- A reusable benchmark framework for Kthena Router (load generator, scenario configs, metrics collection, result aggregation), runnable locally and in CI.</p><p>&nbsp;- A defined set of test scenarios covering typical LLM routing patterns (varying QPS, prompt/response sizes, concurrency, number of backends, routing strategies).</p><p>&nbsp;- End-to-end test procedure documented as a runbook (cluster setup, mock/real backends, how to run, how to interpret results).</p><p>&nbsp;- A benchmark report with metrics (throughput, TPOT, TTFT, GPU/CPU/memory) and analysis of bottlenecks.</p><p>&nbsp;- Upstream PR(s) implementing optimizations for any clear hotspots identified, with before/after numbers.</p><p><br></p>

TBA
Proposal

TMVA SOFIE - GPU Support for Machine Learning Inference

advanced
CERN-HSF•2025Varies350h (Large)

ROOT's TMVA( Toolkit for Multi-Variate Analysis ) has SOFIE (System for Optimized Fast Inference code Emit) which offers a parser capable of converting ML models trained in Keras, PyTorch, or ONNX format into its own Intermediate Representation, and generates C++ functions that can be easily invoked for fast inference of trained neural networks. It is currently implemented for CPU inference along with a SYCL implementation. This project aims to explore different GPU stacks (such as CUDA, ROCm, ALPAKA) and implement GPU-based inference functionalities in SOFIE. Although there exist CPU implementations, working with HEP applications, need for GPU inferences become important. We will be writing optimized GPU Kernels for various operators such as RELU, GEMM, CONV2D, etc. that SOFIE already has for CPU implementation. Testing and experimenting which tech stack (such as CUDA, ROCm, ALPAKA) will be best aligned with SOFIE is our first goal. After getting to know about the pros and cons we can decide which one aligns with our goal. Our next aim would be to integrate all operators for GPU implementation in a incremental fashion ensuring each operator gets enough testing for edge cases. Once we have done basic implementation, we move on to optimizing thread-block config by using tools like Nsight for maximum performance. Once we have implemented our operators for the GPU stack, there is a need for performance benchmarking against popular frameworks like Pytorch/Tensorflow. Last part of the project would be extensive testing and benchmarking memory usage and execution time. I would end the project with proper documentation on how exactly to implement and scopes for further improvements.

pythonc/c++machine learning+6
Student: S.Akash
Code

OpenCL C Support for ClangIR

advanced
LLVM Compiler Infrastructure•2024Varies350h (Large)

Optimizing code for heterogeneous hardware like GPUs requires specialized approaches. While LLVM/Clang supports various GPU programming interfaces, LLVM IR hinders effective analysis for GPU code with its SIMT model. Clang's mid-level IR (ClangIR) based on MLIR is better suited to capture this information from source code. This project proposes adding basic OpenCL C support to ClangIR. Challenges and Solutions: 1. Code Generation Paradigm Shift: CodeGen and Lowering (ClangIR's compilation passes) employ distinct coding paradigms due to their underlying infrastructure (AST reflection vs. MLIR Pass Rewriter). Migrating existing CodeGen code to the Lowering framework could be complex. We will actively debate the trade-off between optimization potential and implementation complexity to propose and execute well-designed, achievable plans. 2. Scattered OpenCL Support Code: Current OpenCL support code is dispersed throughout the codebase, hindering development quality control. Strategies will be developed to address this issue, such as extracting key information from flags like getLangOpts().OpenCL and getOpenCLRuntime(), or implementing systematic code searches to consolidate functionalities and address issues in a structured manner. The final deliverables of this project include a) A set of testcases that combines unit tests with integration tests b) An AST Consumer for OpenCL C (extension of CIRGen) c) A set of MLIR Passes for properly generating SPIR Kernels d) A functional and performance test report (optional) e) Detailed development documentation for all the above parts

cllvmc+++3
Student: 7mile
Code
Proposal

Working on new GEGL ops and porting existing filters as GEGL ops

intermediate
GNU Image Manipulation Program•2026Varies175h (Medium)

GIMP is actively migrating its legacy filter system to proper GEGL operations to enable non-destructive editing, and better PSD compatibility. This project contributes to that effort. First, an Inner Glow layer style will be implemented as a native GEGL operation. The implementation will use a distance transform on the layer's alpha channel to generate a per-pixel glow mask, with parameters including spread, size, opacity, intensity, noise, and blend modes empirically validated against Photopea for PSD compatibility. Once complete, it will be mapped to GIMP's PSD importer so that PSD files with inner glow layer styles import correctly. Second, a Bevel layer style will be implemented as a GEGL operation. Bevel is the remaining unimplemented PSD layer style in GIMP, involving multiple bevel styles, separate highlight and shadow blend modes, and depth and blur interactions. The same empirical approach will be used, systematically studying parameter outputs and implementing each feature step by step. Third, the legacy sharpen filter will be ported to a GEGL meta-operation. The existing implementation relies on the legacy GimpDrawable API with manual pixel loops and is limited to 8-bit images. Since the algorithm is a 3×3 convolution, it can be cleanly expressed as a GEGL meta-op, bringing it into the modern pipeline. Deliverables: A PSD-compatible gegl:inner-glow operation mapped to the PSD importer A PSD-compatible gegl:bevel operation mapped to the PSD importer A ported sharpen filter as a GEGL meta-operation

cGEGL
Student: Waris Maqbool
Code
Proposal

Enabling LLM fine tuning in the WASI-NN ggml plugin (2024 Term 2)

Intermediate
•Varies175h (Medium)

WasmEdge is a lightweight and cross-platform runtime for LLM applications. It allows developers to create LLM apps on a Mac or Windows dev machine, compile them to Wasm, and deploy them on Nvidia machines without any changes to the binary app. It achieves application portability across CPUs and GPUs by supporting a W3C standard API called WASI-NN (https://github.com/second-state/wasmedge-wasi-nn), which abstracts GPU-related AI functions as high-level APIs. At this stage, however, only inference functions are supported. In this project, we aim to support fine-tuning features in WasmEdge. It will improve the developer experience for WasmEdge-enabled LLM tools. To achieve this, we plan to extend the current WASI-NN spec by adding a set of extra APIs, and then implement them by delegating to corresponding functions in llama.cpp embedded in the WasmEdge GGML plugin. Expected Outcome: 1. Use llama2-7b as the base LLM for fine-tuning; the final implementation should handle it correctly. 2. Extend the WASI-NN (https://github.com/second-state/wasmedge-wasi-nn) spec if needed to support the fine-tuning feature. 3. Implement the fine-tuning functions inside WASI-NN ggml plugin. They will call the corresponding functions in llama.cpp, as the inference functions do. 4. Implement the LoRA-related functions inside the WASI-NN ggml plugin to load the pre-trained LoRA and verify the fine-tuned model. 5. Documentation, examples, tutorials, and demonstration are required.

TBA
Proposal

Integrating Advanced CMA-ES Strategies into mlpack

advanced
mlpack•2024Varies350h (Large)

This proposal seeks to enrich the mlpack library by incorporating advanced evolutionary strategies, specifically focusing on enhancing the Covariance Matrix Adaptation Evolution Strategy (CMA-ES) through the integration of Increasing POPulation size CMA-ES (IPOP-CMA-ES) and Self-Adaptive Surrogate-Assisted CMA-ES (saACM-ES). The core of this initiative is to tackle complex optimization problems more effectively by leveraging these sophisticated variants. CMA-ES is celebrated for its adaptability and effectiveness in dealing with real-world optimization challenges by dynamically adjusting the search distribution. To augment this capability, the IPOP-CMA-ES variant introduces a restart mechanism with an increasing population size, aimed at improving the algorithm's ability to escape local optima and discover the global optimum in multimodal functions. Further enhancing the CMA-ES framework, the saACM-ES variant employs a surrogate model to approximate the objective function's landscape, significantly reducing the computational expense of function evaluations. The project is structured around three pivotal deliverables to ensure a clear, measurable progression. Initially, by week 6, the IPOP mechanism will be fully integrated, accompanied by comprehensive tests and documentation. Following this, the saACM-ES strategy will be implemented by week 10, ensuring its reliability and efficiency through extensive testing and well-detailed documentation. The final stage, culminating in week 12, involves refining the implementations, enhancing documentation, and showcasing the new capabilities through examples. This comprehensive approach aims not only to bolster mlpack’s suite of algorithms but also to pave the way for future innovations within the library.

c++pythonmachine learning+4
Student: beny
Code
Proposal

HTCondor Live Tools with Solution Memory

advanced
CERN-HSF•2026Varies350h (Large)

This project enhances the Archi framework by enabling real-time interaction with HTCondor job scheduling infrastructure and introducing a persistent memory system to enhance conclusions drawn on live data with previously encountered similar situations. Currently, Archi operates without access to live system state, limiting it to generic, non-actionable responses when diagnosing job failures. Additionally, solutions discovered during user interactions are not retained, leading to repeated effort and inefficient troubleshooting. To address these limitations, the project introduces a read-only HTCondor tooling layer that allows Archi to query live job data (e.g., via condor_q and condor_history) and provide precise, evidence-based diagnostics. In parallel, a "solution memory" system will be implemented to store validated fixes from past interactions in a vector storage. These solutions will be indexed, embedded, and retrieved through a hybrid search mechanism, enabling Archi to reuse proven resolutions for similar future issues. The main deliverables include: (1) a secure, read-only HTCondor integration layer with structured outputs and error handling, (2) a suite of agent tools for live job inspection and failure diagnosis, (3) a solution memory database with indexing and retrieval capabilities, and (4) full integration into the Archi agent workflow via tools, supported by comprehensive testing, benchmarking, and documentation. By combining live diagnostics with reusable knowledge, this project transforms Archi from a passive assistant into an active, context-aware agent that improves troubleshooting efficiency, reduces computational overhead, and continuously learns from past incidents.

pythonc/c++machine learning+6
Student: Antonio Battaglia
Code
Proposal

Multiplayer, IoT, and Home Assistant support via two MQTT bricks

beginner
International Catrobat Association•2026Varies90h (Small)

Pocket Code currently lacks a scalable way for projects to communicate beyond a single device, which limits its ability to support real-time multiplayer features and IoT use cases. While Bluetooth-based communication exists, it is limited in range and flexibility, and does not support internet-based interaction or integration with modern systems like smart home platforms. This project solves this by adding MQTT-based communication to Pocket Code through simple visual bricks for sending and receiving messages. A shared connection manager handles communication efficiently, with support for secure connections, message routing, and reliability through offline queuing and retries. It also introduces a standard topic structure for IoT integration (e.g., Home Assistant) and enables multiplayer synchronization over Wi-Fi, making Pocket Code a more connected and powerful platform. Key Deliverables: 1. MQTT connection manager with lazy initialization and connection reuse 2. Publish and Receive MQTT bricks integrated into Pocket Code 3. Wildcard topic support and event-driven message handling 4. Offline message queue with automatic retry on reconnect 5. Secure communication using TLS and authentication 6. Standardized MQTT topic conventions for IoT and Home Assistant integration 7. MQTT-based multiplayer synchronization layer 8. Comprehensive automated tests (TDD-based development) This project transforms Pocket Code into a connected programming platform, enabling users to build real-time multiplayer applications and interact with IoT devices using an intuitive visual interface.

javascriptandroidswift+4
Student: Paras_77
Code

Ultimate Alarm Clock III

advanced
CCExtractor Development•2026Varies350h (Large)

Ultimate Alarm Clock III (UAC) aims to evolve into a production-ready, cross-platform mobile application that delivers intelligent, condition-based alarm functionality. The core problem addressed is the limitation of traditional alarms, which lack contextual awareness and flexibility in triggering based on real-world conditions such as location, calendar events, or user activity. To solve this, the project will enhance UAC with advanced conditional logic and deep integrations, including Google Calendar synchronization, Google Assistant voice controls, and customizable task lists linked to alarms. Additionally, the system will improve reliability through enhanced alarm history logging and debugging tools, while enabling seamless synchronization with a companion app. Infrastructure improvements such as CI/CD pipelines, automated testing, and Play Store deployment workflows will ensure scalability and maintainability. A stretch goal includes developing an iOS version with native background execution capabilities to ensure consistent alarm behavior across platforms. The key deliverables include: Implementation of core features such as calendar-based alarms, voice interaction, shared alarms, and task lists Advanced developer diagnostics via alarm history and logging systems Companion app synchronization with real-time data consistency A robust CI/CD pipeline for automated testing and deployment (Stretch) iOS support with native integrations for reliable background execution Together, these deliverables will transform UAC into a scalable, production-grade application with intelligent, context-aware alarm capabilities and a strong foundation for future development.

clinuxvideo+14
Student: Nihal D R
Code
Proposal

Pocket Paint Flutter - Backward Compatibility with the Old Android App

intermediate
International Catrobat Association•2026Varies175h (Medium)

This project aims to complete the transition of Pocket Paint (Paintroid) to Flutter by ensuring compatibility with legacy Kotlin/Java-based .catrobat project files and implementing missing native features in the Flutter version. Currently, older projects cannot be reliably opened, which risks loss of user data and limits adoption of the new app. To solve this, I will design and implement a compatibility layer that parses legacy Kryo-serialized binary data from the native Android application and converts it into the Flutter-compatible JSON-based project structure. The system will follow a structured pipeline (binary decoding → Dart model mapping → JSON serialization → rendering) to accurately reconstruct layers, strokes, and metadata. In addition, I will implement fallback rendering strategies for unsupported tools to preserve visual fidelity and ensure all legacy files remain accessible. Once the compatibility layer is stable, I will focus on implementing selected missing native drawing tools in Flutter to further close the feature gap between the old and new applications. The project will follow a test-driven approach with extensive unit and integration testing using real legacy files to ensure correctness and stability. Deliverables include: - Kryo-to-Dart parsing system for .catrobat files - Fully integrated backward compatibility layer in the Flutter app - Fallback rendering for unsupported legacy features - Comprehensive unit and integration test suite - Documentation for architecture and long-term maintenance - (Stretch goal, if time permits) Implementation of selected high-priority missing native tools (e.g., Fill Tool)

javascriptandroidswift+4
Student: Amit Matth
Code

Improve Kiwix-Android User Experience & Features

intermediate
Kiwix•2019Varies175h (Medium)

<h3>New Features:</h3> <ul> <li><strong>Local sharing of ZIMs using WiFi</strong>: Enable users to share ZIM files locally using WiFi, allowing users to easily share ZIM files with each other without the need of a computer</li> <li><strong>In-app Note Keeping</strong>: Inbuilt note keeper for each ZIM file, allowing users to jot down points from within the app itself</li> <li><strong>Implement #765 (&amp; specific-article sharing)</strong>: Complete the issue and use the new structure to enable users to share articles with others (link to ZIM article for Kiwix users, URL for others)</li> <li><strong>User Feedback activity</strong>: To submit feedback, modelled after the contact page of the website</li> </ul> <h3>Enhancements:</h3> <ul> <li><strong>Navigational drawer based UI</strong>: Help centralise and use a single point of origin for the 3 main actions on the app (View library, Download wikis, Read wiki article)</li> <li><strong>Categorisation</strong> of ZIMs in Library &amp; <strong>Auto-hide system UI bars</strong> during reading</li> </ul> <h3>Other details:</h3> <ul> <li>Document all the code as I write it and fix bugs that I encounter along the way</li> <li>Weekly blog sharing my experience to generate interest in the project and open source contribution</li> <li>Take on additional bugs and issues if the above work gets finished before the final deadline</li> </ul>

pythonandroidjava+11
Student: Aditya Sood
Code
Proposal

Native Support for AI Agent Orchestration and Sandbox Scheduling (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>AI agentic workflows (multi-agent collaboration frameworks, automated evaluation systems such as SWE-bench) frequently spawn and tear down large numbers of short-lived sandboxes (gVisor, Wasm, Kata Containers) to execute skills or tools. Current Kubernetes scheduling models are too heavy for these transient workloads, causing high latency, weak isolation, and APIServer pressure. This project will extend Koordinator to provide first-class support for AI agent scenarios by integrating sandbox runtimes with Koordinator QoS classes, implementing equivalence-class scheduling for near-identical sandbox requests, and introducing a dedicated Sandbox Pipeline that handles pre-warming, capacity reservation, and actionable scheduling feedback to enable agent self-healing.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- Native integration of agent sandbox runtimes (gVisor/Wasm/Kata) with Koordinator QoS classes (LSR, LS, BE) and resource hardening templates</p><p>&nbsp;- Equivalence-class scheduling logic in the Koordinator scheduler that skips redundant Predicate/Priority calculations for batches of similar sandbox pods</p><p>&nbsp;- A Sandbox Pipeline mechanism with pre-warming, automated environment provisioning, and reservation hooks</p><p>&nbsp;- Annotation/Status-based scheduling diagnostics that surface actionable next-step suggestions to upstream agents</p><p>&nbsp;- End-to-end tests and benchmarks demonstrating throughput and latency improvements for high-concurrency sandbox workloads</p><p><br></p>

TBA
Proposal

NetworkX VF2++ Implementation

advanced
NumFOCUS•2022$6k–$13.2k350h (Large)

Graph Isomorphism is an exciting topic regarding networks, but also a fairly complex problem to solve. The goal of the project is the full implementation of the VF2++ algorithm, which is an improved version of the original VF2 algorithm, extended to directed and multigraph settings, in a nonrecursive manner. The brief description of the original algorithm (VF2) is that, after verifying that both the input graphs have the same number of nodes and the exact same degree sequences, it starts constructing a mapping, between the nodes of the two graphs. If the mapping can be extended such that, every node from the first graph is matched to a node of the second graph, then the two graphs are considered to be Isomorphic. The imporved version (VF2++), performs a preprocess, during which, a matching order is found, such that the algorithm is able to recognize the feasibility of the examined branches, avoiding a significant amount of computations by excluding the infeasible ones. The plan to solve the problem is the following. Step 1: extensive research, questions asked and ideas discussed with the mentors. Establishment of a clear understanding of the topic is crucial. Step 2: Decomposition of the problem into smaller and more distinct, less complex sub-problems. These are basically the helper functions that are eventually going to be combined to form the final result. Step 3: Strict testing and reviewing the implementations throughout the entire process. Feedback from the community and the mentors regarding the progress so far. Step 4: Improvements based on the obtained feedback, application of optimizations, possible extra new features added. Step 5: Integration of the final algorithm into the software of NetworkX. Possibly requires the creation of a wrapper class, hosting all the created functionalities. Step 6: Discussions about further improvements out of the scope of GSoC. For example, parallelization with the help of tools such as Cython.

pythonjavascriptr+3
Student: Konstantinos Petridis
Code
Proposal

Robust 3D Mask Engine Performance and Interactive Stability

advanced
Invesalius•2026Varies350h (Large)

InVesalius's 3D mask editor suffers from two critical bottlenecks: slow single-threaded Python geometry math that freezes the UI on high-resolution medical images, and a memory-intensive undo system that copies entire 500×500×500 voxel matrices on every edit, causing out-of-memory crashes on resource-constrained machines. This project addresses both problems through three tightly integrated deliverables. First, the heavy polygon-to-mask projection math will be ported from Python's skimage into multi-threaded Rust via PyO3, using zero-copy rust-numpy bindings to eliminate expensive matrix duplication across the Python/Rust boundary. Second, a new delta-encoded Undo/Redo engine will be built that records only the coordinates of changed voxels rather than full volume snapshots, paired with a disk-backed crash-recovery system and a visual history panel in wxPython for intuitive workflow management. Third, a native interactive 3D Brush Tool will be introduced, allowing users to paint or erase mask selections directly onto the 3D model with a configurable voxel depth, powered by native Rust ray-casting algorithms. Deliverables include a working invesalius_rs Rust module replacing the skimage dependency, the DeltaHistoryStack integrated across all 3D tools (polygon, brush, select parts, thresholding), the Mask3DEditorState decoupling class to eliminate ghost polygon UI bugs, cross-platform unit tests and CI validation, and a contributor benchmark report comparing performance against the current v3.0 baseline.

pythoncythonnumpy+2
Student: ShivamCHAUDHARY
Code
Proposal

Minimal MCP Server Generator for Rocket.Chat

intermediate
rocket.chat•2026Varies175h (Medium)

This project builds a Gemini CLI extension that solves MCP's context bloat problem for Rocket.Chat developers. Current MCP servers expose an entire platform's API surface, meaning every agent session wastes tokens on hundreds of tool definitions the project will never use. The Minimal MCP Server Generator lets developers describe their use case in plain English and produces a production-ready MCP server covering only the endpoints they actually need. The generator goes beyond raw API wrappers by composing multi-step workflow tools: declarative step graphs that chain API calls, AI reasoning, conditional branching, and data transforms into single high-level operations. It supports two compilation targets: a standalone webhook + REST server that runs anywhere, and an Apps-Engine bridged mode for realtime event interception. The key deliverables include: a Gemini CLI extension with endpoint discovery, schema lookup, and project generation tools; a six-pass workflow validation pipeline that catches and self-corrects LLM mistakes before codegen; additive tool generation that adds new tools to existing servers without overwriting; protocol-level test generation via MCP Inspector; runtime hardening with endpoint allow-lists; and a PlatformProvider abstraction with a Mattermost dry-run proving the generator's portability beyond Rocket.Chat. This approach reduces token costs, fits within free-tier limits, and makes MCP-based Rocket.Chat development accessible to any workspace regardless of plan.

javascriptwebrtcmeteor.js+18
Student: Sezal Lagwal
Code
Proposal

Improving the DICOMHawk Medical Honeypot: Profile-Driven Deception with Fingerprinting & Sandbox

beginner
The Honeynet Project•2026Varies90h (Small)

DICOMHawk is an open-source honeypot that emulates a vulnerable DICOM medical imaging server to attract and log unauthorized access attempts. The current v3.0 rewrite is functional at the core protocol level but presents a single fixed identity, lacks a web interface, has incomplete DIMSE handler coverage, and performs no analysis on attacker-submitted payloads. This project transforms DICOMHawk into a profile-driven deception platform. A profile system allows the honeypot to impersonate different medical imaging systems through YAML-backed configuration, controlling the DICOM identity, web-facing surface, and honeytrap behavior per deployment. An attacker-facing web extension built with Flask exposes realistic viewer interfaces and honeytrap endpoints, while browser and environment fingerprinting collects telemetry about attacker infrastructure. On the protocol side, the project completes missing DIMSE handlers (associate, release, abort) and adds DICOMweb (QIDO-RS, WADO-RS, STOW-RS) endpoints. A structured logging pipeline with session correlation ties DICOM, web, and fingerprint events together. A static-analysis sandbox quarantines and analyzes uploaded payloads without execution, shipping with starter YARA rules. Finally, Docker deployment is hardened for safer operation. Deliverables: Profile-based architecture with two starter profiles, attacker-facing web extension with per-profile templates, operator Web API, browser fingerprinting with correlation database, completed DIMSE and DICOMweb handlers, unified JSON event logging with session correlation, static-analysis sandbox with YARA support, and hardened Docker deployment.

pythonandroidmachine learning+16
Student: Vibe
Code

Environmental NeTworked Sensor I: Customizable dashboard, layouts, equations, export, registry.

beginner
UC OSPO•2026Varies90h (Small)

This project makes the ENTS (DirtViz) dashboard easier to grow with real field use. A lot of the UI is still wired together by hand in React, which gets painful when new sensors show up or when people want different views of the same data. The plan is to expose what can actually be plotted using live database information, mainly from the sensor table, so the app lists available sensor names, measurements, and units per cell instead of maintaining long static lists in the frontend. Power and TEROS data may still live on older storage paths for a while, so the catalog will need a clear, documented way to bridge those sources until everything lines up on one model. The headline user feature is a drag and drop dashboard: reorder panels, add or remove them, and keep layout in the URL so someone can share a view with a link. Saving layouts on the server can come later, once the client side layout behavior is solid and easy to reason about. For people comparing multiple cells, the work should also make loads feel snappier by avoiding strictly one after another requests where batching or parallel loads make sense, and by ignoring out of date responses when the selection or date range changes mid flight. After that foundation, there is room for equations for derived metrics with tight server side validation, plus CSV export of what is already on screen. Fancy per panel styling is a lower priority and might stay minimal. Overall this is steady refactoring of the existing Flask and React stack, not a from scratch rewrite, so current APIs stay stable unless an extension is clearly worth it.

pythonc/c++visualization+5
Student: Mehbub_10
Code

TESK - A GA4GH-TES based Kubernetes batch execution service

intermediate
Global Alliance for Genomics and Health•2024Varies175h (Medium)

This project endeavors to revamp the Kubernetes batch execution service to adhere to the Task Execution Service (TES) standards established by the Global Alliance for Genomics and Health (GA4GH). Objectives: Python: Rewrite the existing Java codebase in Python, utilizing the latest version of Python dependencies. Address deprecated code and enhance maintainability, considering the existing task-core is written in Python. Repository Consolidation: Merge all TESK repositories into a unified repository to streamline management and reduce redundancy. Simplify dependency management, ensuring compatibility and synchronized updates across components. Facilitate collaborative development and code sharing among developers. Standardization and Compatibility: Implement TES v1.1.0 To incorporate the latest GA4GH TES features, and comprehensive support for client-side GUI components. Ensure compatibility and interoperability with existing systems. Deliverables: Replacement of Java Springboot API with FOCA-based API implementation. Codebase rewritten in Python with updated dependencies and sanitized code. Unified repository for TESK components for simplified management. Documentation covering the entire system comprehensively. Enhanced collaboration among developers and streamlined build and deployment processes. Milestones: Environment setup and FOCA server, security, and logging configuration. Migration of endpoints as proof of concept (POC). Merge tesk-core into the unified repository. Creation of pydantic data models and data validations. Migration of Kubernetes wrapper. Migration of service and controllers. Upgrade to TES v1.1.0 and update helm charts and docker images. Merge deployment charts and add tests for continuous integration (CI) pipelines.

pythonjavamongodb+10
Student: Javed Habib
Code

[GSOC-273] Test optimization and integration of a resource and security monitoring system

advanced
Apache Software Foundation•2026$6k–$13.2k350h (Large)

This project delivers an integrated framework to optimize cost, strengthen governance, and improve security operations for Apache Beam resources on Google Cloud Platform (GCP). Key deliverables include: GCP Cost Optimization for Taxi Pipelines: A targeted optimization effort for NYC taxi-related Beam tests and examples to reduce unnecessary Pub/Sub and Dataflow consumption. The work includes execution-bound controls, reusable datasets/snapshots, and safer cleanup practices to preserve reproducibility while lowering operational cost. GCP Resource Governance via IaC: A Terraform-based Infrastructure as Code baseline to define and enforce labels, TTL metadata, ownership fields, and lifecycle policies for high-cost services (BigQuery, Dataflow, Compute Engine, Artifact Registry, and Cloud Storage). This enables a version-controlled, auditable, and repeatable infrastructure governance model. Automated Inventory and Drift Detection: A continuous inventory and compliance pipeline integrated with GitHub Actions, BigQuery, and dashboards. The system will collect resource state, classify orphaned/non-compliant assets, run Terraform validation/plan checks, and detect drift between current infrastructure and declared baseline. Service Key Compliance Monitoring: An operational monitoring flow for service account keys that tracks rotation health, propagation status, TTL violations, and suspicious usage signals, with automated reporting and alerts. Safe Remediation Workflows: Disable-then-delete playbooks executed first in dry-run mode and later in controlled execution, providing secure and traceable cleanup of obsolete resources based on validated policy outcomes.

pythonjavascriptjava+7
Student: Hansel Tepal
Code

pgagroal: Replace the I/O Layer

intermediate
PostgreSQL•2024Varies175h (Medium)

The project consists of replacing the I/O Layer of pgagroal, today highly dependent on the libev library, for a pgagroal's own implementation. The so called I/O Layer is an event loop abstracted by libev. The motivation behind this project is the fact that libev is no longer being maintained. Therefore pgagroal needs an efficient (i.e. maintainable, reliable, fast, lightweight, secure, and scalable) implementation of an event loop that can be maintained by the pgagroal community. Currently, pgagroal depends on libev to (a) watch for incoming read/write requests from its connections in a non-blocking fashion; (b) launch timer events; and (c) watch signals. In Linux, these functionalities may be optimally achieved by using io_uring (introduced in Linux kernel 5.1). io_uring is a communication channel between a system's application and the kernel by providing an interface to receive notifications when I/O is possible on file descriptors. io_uring is accessible to system applications through liburing, which is a library that contains helpers for the setup of io_uring. A successful Linux implementation of an efficient event loop for pgagroal necessarily utilizes io_uring -- as well as other Linux I/O interfaces (e.g. stdio) -- for efficient I/O. In FreeBSD, these functionalities may be optimally achieved by using kqueue (introduced in FreeBSD 4.1). kqueue is an event notification interface that allows monitoring of multiple file descriptors. Like io_uring in Linux, kqueue enables non-blocking I/O operations, but it is specifically designed to fit into the FreeBSD kernel's event-driven architecture. The objective of this proposal is to provide a plan to achieve such efficient implementations in both Linux and FreeBSD, which shall be, at the end of this program, at least as efficient as libev, but fully maintained and controlled by the pgagroal community.

cpostgresqlperl+8
Student: decarv
Code
Proposal
Showing 3121 - 3144 of 3179 Projects
129130131132133
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal