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

Cloud-native OGC SensorThings API

intermediate
52°North Spatial Information Research GmbH•2024Varies

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)

OGC SensorThings API is an international standard to eliminate vendor lock-ins in IoT systems and to create an open geospatial ecosystem by defining a standard data model and describe how to retrieve the ingested data. However, the standard by itself does not specify a way to physically store the data. Most of the current server implementations are all based on Postgres databases using the PostGIS extension. Unfortunately, relational databases are not a great choice to store large volumes of data, which is often the case with IoT applications. As a result, retrieving large volumes of data from any of the open source SensorThings API servers is painfully slow. Modern data lakehouse standards and cloud-native geospatial file formats offer a scalable, modular, cost-effective and a much faster way to store and work with large volumes of geospatial data on the web. Specifically, Apache Iceberg is an open table format for organizing data lakes in object stores and ensuring ACID guarantees. GeoParquet is a cloud-native geospatial file encoding, based on a columnar data storage format for tabular data that significantly compresses the data and improves querying efficiency. A cloud native SensorThings API extension using Apache Iceberg could significantly enhance the standard's ability to ingest and aggregate large heterogeneous streams of sensor data. The proposal hence puts forth a design architecture for any SensorThings API server to use Iceberg to store and retrieve sensor data in a more efficient manner reducing memory overhead and network latencies when retrieving such data over the web. Eventually, as GeoParquet gets merged into Iceberg, the implementation will support a much faster alternative to existing SensorThings API implementations for handling sensor data at scale.

javascriptandroidjava+2
Student: Humaid Kidwai
Code
Proposal

Edge-Native Inference for Lightweight LLMs (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>This project focuses on validating KubeEdge as an edge-native infrastructure for lightweight large language model inference. As more AI services move from the cloud to edge devices, lightweight LLMs provide a practical way to reduce latency, protect data privacy, and support local intelligence under limited resources.</p><p>The mentee will deploy one or more lightweight LLMs on KubeEdge edge nodes and evaluate the complete workflow, including model packaging, workload scheduling, service exposure, lifecycle management, and performance measurement.</p><p>The project is expected to produce a practical reference for running generative AI workloads on edge nodes managed by KubeEdge.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- Successfully deploy and run one or more small-parameter large models on KubeEdge edge nodes, and complete end-to-end inference workflow validation.</p><p>&nbsp;- Explore deployment methods and best practices for managing lightweight model services based on KubeEdge.</p><p>&nbsp;- Evaluate basic performance on edge devices, including startup time, memory usage, inference latency, and runtime stability.</p><p>&nbsp;- Fix issues discovered during validation, and submit PRs to KubeEdge or related example repositories when necessary.</p><p>&nbsp;- Publish a blog or document to kubeedge/website introducing how to deploy and run small-parameter large models based on KubeEdge.</p><p>&nbsp;- Optional: complete example validation with a lightweight scenario, such as local Q&amp;A, document summarization, or lightweight multimodal inference.</p><p><br></p>

TBA
Proposal

#40: QC-Studio-integrated quality control toolkit for MRI datasets

intermediate
INCF•2026Varies175h (Medium)

MRI quality control (QC) is an essential but highly manual and repetitive process in neuroimaging research. Currently, reviewers must navigate scattered directories and mentally integrate diverse outputs, such as 3D volumes, SVG montages, and isolated metrics, to make a reliable assessment. This "hidden labor" takes significant time away from actual research, introduces variability across different raters, and results in decisions that are poorly documented and difficult to audit. This project aims to transform QC-Studio from a working prototype into a robust, Nipoppy-integrated application. The core of the solution focuses on replacing hardcoded file paths with a scalable, config-driven architecture utilizing Nipoppy's DatasetLayout API. Additionally, the project will inject essential quantitative context into the review process by building an Image Quality Metric (IQM) distribution panel. Finally, it will establish a structured "Evidence Bundle" to experimentally evaluate whether a lightweight LLM-based assistant can improve review efficiency by summarizing quantitative data and flagging anomalies. Key Deliverables: 1) Config-Driven Architecture: A unified Streamlit application featuring dynamic subject loading, unified pagination, and manifest.tsv integration across multiple processing pipelines without hardcoded paths. 2) Quantitative Evidence Layer: An interactive IQM panel that visualizes subject-level metrics against local datasets and crowdsourced reference distributions (MRIQC Web API), complete with rule-based outlier detection. 3) Experimental AI Guidance Prototype: A foundational integration displaying pre-generated, LLM-authored summary reports within the dashboard, accompanied by an evaluation report assessing factual accuracy and workflow impact.

pythonjavac+++7
Student: Niusha Sadat Mirhakimi
Code
Proposal

Project 15.1 Analysim, INCF- implementing new features in project dashboard and notebook management.

intermediate
INCF•2024Varies175h (Medium)

Project Deliverables • Implement a Project edit button, file and project rename functionality, fix edit project popup , allow editing list of notebooks , and add images to each type of notebook. • Implement support for Jupyter notebooks. Users should be able to upload, view, and edit Jupyter notebooks on the platform. Use Jupyter Lite, or nbviewer, or nbconvert to render notebooks in HTML format. • Allow users to fork existing projects. Forking should create a new project that is linked to the original, allowing users to experiment with changes without affecting the original project. • Improve the project creation and editing process. Add validations for project names to ensure uniqueness. Enhance the project edit functionality to prefill forms with existing information and update project names and routes when edited. • Implement a user permission system to differentiate between project members and followers. Users can join projects as members or follow them with the project owner's permission. • Set up a continuous integration system for automated Docker container generation. • Migrate the project's blob storage to Jetstream. Ensure a seamless transition with minimal downtime and data loss. Set up automated, regular database backups. • Bug Fixes: Address existing bugs in the platform, such as issues with the registration code, disappearing navbar account menu, and join button behavior, to improve user experience and platform stability. • Implement an organization system where users can create and manage organizations. Organizations can have multiple projects and users associated with them. Define roles such as admin, members, and followers within organizations to manage permissions and access levels. • Implement comments in projects and logs along with a reply-to field, vote field to up/down voting, and a ‘flag’ field for flagging.

pythonjavac+++7
Student: Uday Biswas
Code

Sugarizer Security and Availability

intermediate
Sugar Labs•2021$3k–$6.6k175h (Medium)

<p>The objective of this project is to keep Sugarizer growing by enhancing two core concepts for our deployments: <strong>Security and Availability.</strong></p> <h4>📝 Deliverables</h4> <ul> <li>Fix current issues/features request on <a href="https://github.com/NikhilM98/sugarizer-school-portal-server/issues" target="_blank">Sugarizer-School-Portal</a></li> <li>Update package/chart versions for Sugarizer School Portal.</li> <li>Migrate from deprecated <a href="https://github.com/helm/charts/tree/master/stable/mongodb-replicaset" target="_blank">helm/mongodb-replicaset</a> chart to <a href="https://github.com/bitnami/charts/tree/master/bitnami/mongodb" target="_blank">bitnami/mongodb</a> chart.<ul> <li>While maintaining support on different Kubernetes providers.</li> </ul> </li> <li>Add Two Factor Authentication feature for Sugarizer School Portal to enhance user's security.<ul> <li>TOTP Enable and Disable feature</li> <li>TOTP Verification upon logging in after Two Factor Authentication has been enabled.</li> </ul> </li> <li>Add Two Factor Authentication feature for <a href="https://github.com/llaske/sugarizer-server" target="_blank">Sugarizer -Server</a> Dashboard to enhance user's security.</li> <li>Update the prevailing tests and write tests for new features added.</li> <li>Update Setup Scripts and documentation for <a href="https://github.com/NikhilM98/sugarizer-school-portal-server" target="_blank">Sugarizer School Portal</a></li> </ul> <h4>🎉All of the aforementioned deliverables were attained during GSoC coding period.</h4>

pythonjavascriptgtk++10
Student: Jaikishan Brijwani
Code
Proposal

Adaptive Closed-Loop Neuromodulation: An Agentic Framework Using Synthetic EEG Data

advanced
Department of Biomedical Informatics, Emory University•2025Varies350h (Large)

This project focused on developing ACUMEN (Active Cross-Entropy Method with Uncertainty-driven Neural ODEs), a data-efficient framework for system identification in healthcare. Unlike fixed or passive approaches, ACUMEN actively explores uncertain regions of physiological dynamics to accelerate learning. The goal was to build patient-specific models that can support adaptive therapies such as neuromodulation. At its core, ACUMEN couples Neural Ordinary Differential Equations (Neural ODEs) with Cross-Entropy Method Model Predictive Control (CEM-MPC). An ensemble of Neural ODEs serves as a surrogate model for continuous-time physiological signals. Ensemble disagreement quantifies epistemic uncertainty, which then drives exploration: CEM-MPC plans candidate interventions and prioritizes those that maximize model uncertainty, enhanced with optimistic rollouts, novelty-based objectives, and adaptive scaling. This iterative process collects the most informative data, retrains the ensemble, and progressively refines predictions. Key Deliverables: 1- A simulation pipeline using the RL-DBS environment to generate realistic EEG-like signals and stimulation effects. 2- A dataset of stimulation–response pairs across clinically relevant ranges. 3- A trained Neural ODE ensemble surrogate model with documented accuracy and uncertainty metrics. 4- An uncertainty-driven RL environment with CEM-MPC–based exploration. 5- Evaluation showing up to 24.2% error reduction and tighter uncertainty bands compared to random data collection. 6- Open-source code, documentation, and final report. Impact: By actively probing uncertain regions, ACUMEN reduces sample complexity and enables efficient, personalized system identification. This paves the way for safer, more effective closed-loop therapies in neuromodulation and beyond.

pythonjavascriptjava+4
Student: Amirhossein Afkhami Ardekani
Code

Open-source RISC-V Vector accelerated sparse linear algebra library

Intermediate
•Varies175h (Medium)

<p><span style="color: rgb(34, 34, 34);">Sparse linear algebra is fundamental to many domains including scientific computing, machine learning, graph analytics, and large-scale simulations. In modern machine learning workloads, especially pruned neural networks, sparsity is intentionally introduced to reduce computation and memory usage. While several specialized hardware accelerators exist for efficiently executing sparse matrix operations in such workloads, these solutions rely on dedicated hardware and are not always available in general-purpose systems.</span></p><p><br></p><p><span style="color: rgb(34, 34, 34);">Within the RISC-V ecosystem, optimized libraries such as OpenBLAS provide highly efficient implementations for dense linear algebra operations. However, similar support for sparse matrix multiplication optimized for the RISC-V Vector Extension remains limited.</span></p><p><br></p><p><span style="color: rgb(34, 34, 34);">This project aims to develop a lightweight C library that implements key sparse linear algebra primitives particularly sparse matrix multiplication using RISC-V vector intrinsics. The project will handle CSR and CSC sparse storage formats, vectorization strategies, and memory-efficient traversal techniques to better exploit data-level parallelism on RVV-enabled processors. The outcome will include a clean API for sparse matmul operations, optimized implementations using vector intrinsics, and well-documented source code. The goal is to provide an accelerator-independent software solution that enables efficient sparse computation on general-purpose RISC-V vector processors.</span></p>

TBA
Proposal

Characterizing I/O Performance for ML Data Loaders at Scale using Darshan

advanced
CERN-HSF•2026Varies350h (Large)

Modern machine learning workflows in High Energy Physics increasingly rely on large-scale datasets, where the data-loading stage can become a primary bottleneck for performance and scalability, particularly due to the lack of visibility into the I/O behavior of data-loading pipelines. While model performance is extensively studied, data ingestion remains comparatively under-characterized and often limits scalability due to inefficient access patterns, filesystem contention, and poor interaction between data formats and loading strategies. This project addresses this gap by developing a reproducible benchmarking and analysis framework for characterizing data-loading performance in ML pipelines. The system will integrate the Darshan I/O characterization tool to capture system-level access patterns and combine them with application-level metrics such as throughput and runtime. It will support multiple data formats and compare different loading approaches, including the native PyTorch DataLoader and a ROOT-based loader. The methodology consists of controlled experiments that vary data formats, loader configurations, and execution parameters. Results will be processed through an analysis layer to identify recurring patterns and bottlenecks, and a diagnostic component will detect inefficiencies and provide actionable recommendations. The main deliverables of the project are: - A modular CLI-based benchmarking system for dataset generation and ingestion, configurable experiment execution, and structured result collection. It will enable reproducible experiments across data formats (NumPy .npz, HDF5, CSV, ROOT RNTuple), loader implementations, and execution configurations. - Integration of Darshan for automated I/O profiling and trace collection - A curated set of benchmark experiments covering representative combinations of data formats, loader implementations, and configuration parameters - Documentation and a final report summarizing findings and best practices

pythonc/c++machine learning+6
Student: AtikSantellan
Code

GSoC 2025 Proposal - Interaction to Next Paint (INP) subparts

advanced
Chromium•2025$6k–$13.2k350h (Large)

Proposal Summary: Interaction to Next Paint (INP) Subparts Problem Statement: The recently introduced Interaction to Next Paint (INP) metric, integrated into the Core Web Vitals (CWV) system in 2024, aims at measuring user interaction performance. However, INP lacks granularity, making it difficult for developers to diagnose and address specific latency issues within different stages of event processing and rendering. Solution Approach: To enhance the diagnostic capabilities of INP, this proposal suggests breaking down the INP metric into its sub-dimensions—input delay, processing time, and presentation delay—by leveraging modifications to Chromium’s Event Timing API. These fine-grained timestamps will be transmitted from the Renderer process to the Browser process via Mojo IPC, eventually integrating these metrics into the UKM metric system and CrUX experimental dataset. The project will involve updating the PageLoadMetricsSender to include detailed timing data for each event, as well as enhancing the UkmPageLoadMetricsObserver to handle both old and new data formats seamlessly. Deliverables: 1. Prototype Verification: Establish a proof-of-concept for collecting sub-dimension data using Chromium’s debugging environment. 2. Mojo Protocol Modification: Extend existing IPC interfaces to support new subpart timings. 3. UKM Integration: Implement new UKM metrics reporting and update relevant configurations. 4. Test Suite Development: Develop comprehensive tests including Web Platform Tests/WPT cases and unit test coverage. 5. Performance Regression Testing: Analyze benchmark reports and memory usage to ensure no negative impact on performance. 6. Documentation & Wrap-up: Provide detailed design documentation and outline plans for integrating improvements into CrUX.

pythonjavascriptjava+2
Student: Guo Yi
Code
Proposal

Extending the WikidataComplete plugin for enabling data donations, recommendations, and gamification

intermediate
Wikimedia Foundation•2022Varies175h (Medium)

Wikidata is one of the largest hosts of open data. Missing or new information needs to be added by community members. Otherwise, the knowledge base will dry out and be obsolete after a while. My project's goal is to create an ecosystem that will consist of Web service interfaces to push data from different sources, s.t. researchers. The industry can easily integrate it into their systems and efficiently help to extend the Wikidata knowledge base. The impact of this will be data donations will be possible directly via different sources. The process will become easier and less time-consuming for contributors. Hence, the quality and quantity of the open data offered by Wikidata will increase. I will later try to implement a recommendation engine that suggests agreeable facts to Wikidata editors that are likely to be in their area of expertise. Also, gamification features to show appreciation to Wikidata editors, e.g., a badge Web service allowing users to integrate their score/rank into their profiles on social networks. That will be encouraging for the editors. Goals (1) Implement Webservice interfaces for data donations, i.e., sets of approvable facts (which should also contain links to evidence, etc.) (2) Implement a recommendation engine that suggests agreeable facts to Wikidata editors that are likely to be in their area of expertise. (3) Extend the gamification features to show appreciation to Wikidata editors. Example: a badge Web service allowing users to integrate their score/rank into their profiles on social networks (e.g., on Wikidata’s user page, GitHub profile, Linkedin profile) to show their dedication and activate other users. Impact (1) Data donations are possible and at the same time, an efficient approval process is supported. (2) More fact ingestions with the help of the Wikimedia community. (3) Faster integration of new facts into Wikidata.

javascripthtmlphp+7
Student: Lalit Suthar
Code

Enhancing the Cohort Discovery Chatbot

beginner
Data for the Common Good•2025Varies90h (Small)

The process of identifying patients meeting certain criteria is crucial to advance research and contributes to new knowledge in medicine and health. So, data on specific populations are necessary to perform such research. However, faced with vast and complex healthcare data, traditional data analysis and processing methods prove to be inadequate.For example, cohort discovery is a popular existing tool that can allow researchers to safely explore the data in the Research Data Warehouse (RDW) prior to making a data request. But in real-world scenarios, the cohort discovery tool is not easy to use because users need to get familiarized with the workflow of the tool and it may even acquire them to write complex query languages, such as SQL. We also observe this inconvenience with the existing cohort discovery tool in D4CG, an open-source organization of the Pediatric Cancer Data Commons. As it works on building communities, platforms and becoming the critical data source for researchers and organizations, it has become evident that implementing an efficient cohort discovery tool would significantly enhance Research and Development (R&D) efficiency. With the rapid growth power of Large Language Models (LLM), this project proposes an innovative solution to enhance the cohort discovery tool by developing a query agent based on LLM to achieve more flexible and efficient data analysis and processing. To prototype this query agent, this project focuses on refining natural language understanding (NLU), improving query accuracy, supporting more complex filters, and integrating feedback mechanisms to learn from user interactions. For example, Given a user question like “Can you help me find patients aged between 20 and 40 who have a history of toothache in the Clinic Table?”, the query agent takes the question along with the corresponding database schema as input. It then generates a query output that satisfies the user’s request.

pythonjavascriptkubernetes+2
Student: Regina Huang
Code
Proposal

Create visual programming nodes for generating BIM data with IfcSverchok

advanced
BRL-CAD•2022Varies350h (Large)

Industry Foundation Class (IFC) is the leading open data format for the built environment, based on the ISO 16739-1:2018 standard. It’s the foundation of the openBIM workflow. Today, IFC is most often used as a software-agnostic way of exchanging building information, but there is increasing interest in using the IFC schema as the native format for working with BIM data. Blender, with its mature modelling and rendering capabilities, has the potential to become a powerful BIM authoring tool. Open data and integrated python console already give many options for customising the data and meta data of any geometric object. The BlenderBIM plugin introduces the possibility to assign the properties of IFC classes to native blender geometry and export correctly structured IFC files through the use of the IfcOpenShell software library that already contains many useful functions to work with the IFC schema. The goal of this project is to develop a plugin for the visual scripting language for Blender, Sverchok, that would enable creating IFC geometry and data through the visual programming nodes, allowing the users to create their own parametric workflows and incorporate IFC data directly into their design process. An equivalent plugin for Sverchok, would allow an integrated parametric design and native IFC workflow to be completed fully inside the FOSS environment. It would also be a strong foundation for integrations with other Building Performance Simulations (BPS) tools. Integration and porting of the nodes to FreeCAD would also be possible. Some of the basic nodes are already coded under the IfcSverchok project. The work will involve testing the existing nodes and writing many more to support the full use case. Since the IFC schema is very large, and often difficult to grasp for new users, emphasis will be on integrating the concepts of IFC into a typical design process in a natural manner and communicating the relevant information comprehensively to the user.

pythonc/c++opengl+6
Student: Martina Jakubowska
Code

Graph Representation Learning for Fast Detector Simulation

advanced
Machine Learning for Science (ML4SCI)•2025Varies350h (Large)

High-fidelity detector simulations are critical for accurate analysis in particle physics, but traditional Monte Carlo-based methods are computationally expensive. DeepFalcon introduced a promising approach using Graph Variational Autoencoders (GVAE) that treat particle hits as graph nodes, enabling faster inference while maintaining high accuracy. This implementation used CMS Open Data of boosted top quark jets and considered only the ECAL layer of the detector, achieving a 400× speedup in reconstructing jets compared to traditional simulations. The model architecture employed GraphSAGE layers and mincut pooling, while training used Adam optimizer with a hybrid loss function combining MSE and KL divergence. However, the current approach is limited to single-layer detector responses and doesn't fully capture the correlations between multiple detector components. This project aims to extend DeepFalcon’s GVAE architecture to support multi-layer detector systems, specifically incorporating Tracker, ECAL, and HCAL layers simultaneously. The proposal is structured into two phases: Phase I will focus on enhancing the graph data representation by including all three detector layers and designing optimized connectivity patterns that capture spatial and inter-layer dependencies. Phase II will explore advanced pooling techniques and alternative message-passing strategies to improve latent representation quality and model generalization, while maintaining fast inference speeds. All components will be implemented using Python and relevant machine learning libraries such as PyTorch Geometric. Expected deliverables include a multi-layer GVAE model, benchmark comparisons against existing results, and detailed analysis of the architectural choices. This project contributes toward advancing fast simulation techniques in high-energy physics by enabling more comprehensive and scalable detector modeling.

pythonmachine learningc+++2
Student: Rushil Singha
Code

Mapping the RISC-V Extensions Landscape Mentorship Project

Intermediate
•Varies175h (Medium)

<p>The RISC-V Extensions Landscape is an open-source, interactive web tool that serves as a single searchable reference for the entire RISC-V Instruction Set Architecture ecosystem. It visualizes all ratified, draft, and discontinued extensions, displays per-instruction 32-bit encoding diagrams with match/mask values, and supports filtering by RISC-V profiles (RVA20, RVA22, RVA23, RVB23). The project is live at https://rpsene.github.io/riscv-extensions-landscape/ and built with React, Tailwind CSS, and Webpack.</p><p><br></p><p>The core challenge is that only 83 of 220 cataloged extensions (38%) have their instruction details fully mapped. The remaining 137 extensions exist in the catalog but lack instruction encodings, leaving significant gaps in supervisor-level extensions (trap, interrupt, memory), vector subsets, and vector cryptography bundles. Additionally, 104 extension tags from the upstream riscv-opcodes project remain unlinked due to naming mismatches between the source data and the catalog, preventing automated synchronization.</p><p><br></p><p>The mentee will work on three main tasks: (1) reconcile the 104 mismatched extension tags from riscv-opcodes with the catalog's naming conventions, enabling the sync script to automatically populate instruction data; (2) research and map instructions for the remaining extensions, particularly supervisor-level extensions that define CSR behaviors and vector subset extensions that represent subsets of the V extension; and (3) improve the sync tooling to detect gaps and generate coverage reports automatically. The mentee will gain hands-on experience with the RISC-V ISA, open-source data engineering, and React-based visualization tools.</p><p>&nbsp;</p>

TBA
Proposal

Project 11 - Composable Kale Notebooks with Visual Pipeline Editor

intermediate
Kubeflow•2026Varies175h (Medium)

Kale compiles a single Jupyter notebook into a Kubeflow Pipeline by parsing cell tags, detecting data dependencies with PyFlakes, and generating KFP DSL. But real ML work rarely fits in one notebook ,teams split preprocessing, training, and evaluation across separate notebooks, and today there's no way to compose them through Kale without dropping down to the KFP SDK manually. This project extends Kale with multi-notebook composition and a visual pipeline editor. Each notebook declares typed inputs and outputs (KFP artifacts like Dataset, Model, Metrics or parameter types). A new workflow compiler processes multiple notebooks and compiles them into a single Kubeflow Pipeline, with each notebook becoming a KFP sub-pipeline that preserves its internal steps. A visual editor built as a JupyterLab DocumentWidget handles assembly ,drag notebooks onto a canvas, connect typed ports, compile and run. Deliverables: #1.Notebook interface declaration system (backend + frontend) — explicit typed inputs/outputs per notebook, integrated into existing NotebookConfig and the Kale sidebar UI #2. Workflow data model and .kale-workflow file format with DAG validation (cycle detection, type checking, reference resolution) #3. Workflow compiler that processes each notebook through the existing NotebookProcessor → Compiler pipeline, wraps output as sub-pipelines, and generates a top-level KFP pipeline wiring them together through artifacts #4. CLI support: kale --workflow path/to/workflow.json #5. Visual DAG editor in JupyterLab using React Flow — drag-and-drop from file browser, typed port connections, properties panel, compile/run actions via Kale's existing RPC layer #6. End-to-end tests on a real KFP cluster, user documentation, and example workflows

pythontensorflowkubernetes+5
Student: Yash_vrd
Code

IBus Customize

intermediate
openSUSE Project•2021$3k–$6.6k175h (Medium)

<p>Currently (Before GSoC 2021 during application), the <a href="https://en.wikipedia.org/wiki/Intelligent_Input_Bus" target="_blank">IBus</a> theme follows the global <strong>GNOME-Shell theme</strong> in GNOME and the global <strong>GTK theme</strong> in other desktop environments, and IBus lacks customization for users in GNOME.</p> <h4>Main Focus</h4> <p>This project aims to make IBus themes separate from the current <strong>GNOME-Shell theme</strong> and <strong>GTK theme</strong> so that users can customize it with other <strong><a href="https://www.gnome-look.org/browse/cat/134/" target="_blank">GNOME-Shell themes</a></strong> and <strong><a href="https://www.gnome-look.org/browse/cat/135/" target="_blank">GTK themes</a></strong>.</p> <h4>Other Goals</h4> <p>Improve the UI usability for IBus in GNOME. That is, to add more features, including customization of orientation, animation, font, opacity. Support right-click to switch the input source or open the tray menu, scroll to switch among pages or candidates, fix candidate box and IME switch list order, ASCII mode auto-switch, reposition, show or hide candidate box page buttons, set system tray settings, input source indicator with settings. Theme and background picture follow GNOME Night Light Mode, and so on. These customizations will make users find IBus in GNOME familiar if they have just switched from another platform. Eventually, an extension providing full customization of appearance, behavior, system tray, input source indicator for IBus will be available.</p> <h4><a href="https://github.com/IBus-Customize" target="_blank">Archived Codebase</a></h4>

pythonlinuxjavascript+11
Student: Songlin Jiang
Code
Proposal

Automated Documentation Sync Bot for Krkn-Chaos Projects (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>The krkn-chaos/website repository hosts the unified documentation for the entire krkn-chaos ecosystem (krkn, krkn-hub, krknctl, krkn-ai, krkn-operator, cerberus, etc.) as a Hugo/Docsy site deployed at krkn-chaos.dev. Currently, when changes are made to any of these upstream projects — such as adding a new scenario, modifying configuration options, or updating CLI flags — someone must manually open a PR against the website repo to update the corresponding docs. This is tedious, easy to forget, and often leads to documentation drift where the docs no longer match the actual tool behavior. This issue proposes building a bot or GitHub Action-based workflow that detects documentation-impacting changes in upstream krkn-chaos repositories and automatically creates a draft PR on the website repo with the relevant documentation updates. The bot would analyze the scope of the change (e.g., new config fields, updated parameters, new scenario) and generate or update the corresponding Hugo content files, following the existing content structure and conventions (tabbed scenario layouts, parameter tables, etc.).</p><p><br></p><p>Expected Outcome:&nbsp;</p><p>&nbsp;- Build a GitHub Action or bot that triggers on merged PRs in upstream krkn-chaos repos and automatically creates draft documentation PRs on the website repository following existing Hugo/Docsy content conventions.</p><p>&nbsp;- Support common change types including new or updated config fields, CLI flag changes, new chaos scenarios, and modified parameter tables.</p><p>&nbsp;- Enable interactive refinement of generated documentation PRs through review comments, similar to code review bots like CodeRabbit.</p><p><br></p>

TBA
Proposal

Linux-Intelligence-OCR-Solution(LIOS) - Enhancement

advanced
Zendalona•2025Varies350h (Large)

Summary: The goal of this project is to improve the Linux-Intelligent OCR Solution (LIOS), an open-source tool for text extraction from images, scanned documents, and PDFs using Tesseract and Cuneiform OCR engines. The primary focus will be on enhancing usability, accessibility, and performance, particularly for visually impaired users, while also addressing several existing issues. Problem: LIOS is a powerful tool, but there are several issues that hinder its usability and accessibility. These include problems with the UI/UX design, scanner compatibility, OCR integration, and the lack of proper error handling, which often leads to crashes. Additionally, there are several other bugs that need attention, such as issues with text focus, icon display, and preview functionality. Solution: The project will focus on addressing these issues and improving the overall user experience: UI/UX Improvements: Simplify the interface and improve accessibility, particularly for low-vision users. Bug Fixes & Code Refinements: Address the following specific issues: Text Focus: Ensure the textview regains focus after using Goto Line and Goto Page. Tab Focus: Improve tab focus handling for better navigation. Icon Display: Fix the larger icon issue in the icon view for consistent UI presentation. Print Preview: Fix the Print Preview functionality, which currently isn’t working as expected. Error Handling: Implement proper error handling to prevent crashes and unexpected behavior. Image Rotation: Resolve the automatic deletion issue when rotating selected areas of the image. Find/Replace Accessibility: Ensure the Find and Find & Replace features are fully accessible and functional. Scanner Compatibility: Improve compatibility with various scanner models, ensuring better cross-platform support. Tesseract Integration: Enhance the detection of Tesseract data paths for more accurate OCR functionality.

pythonjavascriptandroid+2
Student: Nihal_Rodge
Code
Proposal

macOS app bundle (175 hours)

intermediate
Synfig•2025Varies175h (Medium)

The current macOS app bundle creation process for Synfig relies on an outdated Bash script that is slow, error-prone with incorrect paths, and lacks code signing, hindering efficient distribution and user trust. This project aims to replace the script with a robust, automated solution to streamline bundle generation, ensure macOS security compliance, and enhance the native user experience. By leveraging Python for dependency collection, C++ for environment setup, and CMake/CPack for packaging, the project will deliver a signed, distributable SynfigStudio.app bundle. Key improvements include faster dependency gathering, proper code signing, embedded environment setup, Python/lxml integration, and macOS-native interface enhancements. Approach: • Develop a Python script to efficiently collect and stage dependencies, optimizing with caching and parallelization. • Implement code signing in reverse dependency order using codesign, including Python and lxml binaries. • Remove the external launcher script by embedding environment setup in the C++ entry point. • Package Python and lxml into the bundle, ensuring compatibility and signing. • Integrate CPack into CMake to generate a polished .dmg installer. • Enhance the UI with macOS-native menu bar and window behaviours using GTK. Deliverables: • A CMake/CPack-based build system producing a signed SynfigStudio.app bundle. • A Python script for automated dependency collection and path rewriting. • Code signing support for all binaries, including Python and lxml. • Embedded environment setup within SynfigStudio, eliminating the launcher script. • A bundled Python runtime with lxml, fully signed and functional. • A distributable .dmg installer generated via CPack. • macOS-native UI improvements (e.g., menu bar, shortcuts, dialogs boxes). • Comprehensive documentation covering installation, usage, and build instructions.

c++gtkgtkmm+2
Student: Nitish Itankar
Code
Proposal

Weather Routing Tool

intermediate
52°North Spatial Information Research GmbH•2025Varies175h (Medium)

The Weather Routing Tool is a system designed to find optimal shipping routes between two geographic points, taking into account weather data, local boundaries, and other environmental factors. The tool currently assumes constant ship speed and has a basic genetic algorithm for route optimization. This project aims to improve the routing logic by: Introducing ship speed optimization along a route Enhancing the genetic algorithm for more effective route modeling Improving the usability and extensibility of the tool for end-users Project Deliverables 1. Ship Speed Optimization Goal: Allow optimization of ship speed along the route instead of assuming it constant. Approach: Modify the Isofuel algorithm to use speed as a minimization criterion. Define a new scoring function: score = (distance / time) - alpha * remaining_distance Enable this feature via configuration: ISOCHRONE_MINIMISATION_CRITERION = "speed" 2. Genetic Algorithm Enhancements Goal: Improve the existing genetic algorithm’s efficiency and flexibility. Planned Improvements: Add multi-objective cost function support (e.g., fuel, speed, wear & tear). Enhance crossover logic with: Multi-point crossover Uniform crossover Adaptive crossover Improve mutation strategies and population initialization. Leverage the pymoo library with custom configurations. 3. Tool Usability Improvements Goal: Make the Weather Routing Tool more modular, user-friendly, and extensible. Key Features: Dynamic Python file injection using CLI: python cli.py -f config.template.json custom.py Load modules dynamically with: load_file_as_module(path: str) -> types.ModuleType Command-line utility packaging: Tool installable via PyPI (pip install wrt) Usage: wrt -h Rationale: Enable users to add custom boat models and configurations without modifying core code.

javascriptandroidjava+2
Student: shreyass-ranganatha
Code
Proposal

ABI Compliance Reporting System

advanced
PostgreSQL•2025Varies350h (Large)

PostgreSQL introduced Server API and ABI Stability Guidance to help extension authors understand compatibility expectations. The policy ensures ABI stability between minor releases (e.g., 17.0 to 17.1) but allows changes in major versions. Currently, committers rely on manual reviews to enforce this, which occasionally leads to unintended ABI changes. A recent example occurred in PostgreSQL 17.1, where an ABI-breaking change was shipped and later reversed in 17.2. This incident highlights the need for an automated process to catch such issues before release. To enforce ABI stability, this project will monitor PostgreSQL’s repository across STABLE branches, detecting any ABI breakage early. Since ABI changes depend on system architecture, OS, and compiler, the tool will be developed as an extension to PostgreSQL Build Farm, leveraging its infrastructure to handle diverse configurations. Git receive hooks are unsuitable as PostgreSQL does not allow them due to repository performance concerns. As the frequency of commits on the PostgreSQL stable branches is very low, build farm’s cron based clients (animals) can simply compare the latest commit build(which it already does) with the latest release tag or the most recent minor release to get the ABI breakage, if any. The Libabigail suite (abidw, abidiff) will be used for ABI compliance checks, currently supporting GCC and Clang, with future expansion planned for other compilers. The system will generate ABI compliance reports on every run and will send to the build farm server and notify the community about breaking changes. This project will include the development of a Build Farm Client Perl Module that generates ABI compliance reports and report any ABI Breaks to the community. This project will strengthen PostgreSQL’s ABI stability process, preventing unintended breakages and ensuring smoother minor releases.

cpostgresqlperl+8
Student: Mankirat Singh
Code
Proposal

`matcher.js` library and `Leaflet.DistortableImage` overhaul

advanced
Public Lab•2019Varies350h (Large)

<p>This project is divided into two parts, namely, building a <code>matcher.js</code> library and revamping Public Lab's <a href="https://github.com/publiclab/Leaflet.DistortableImage" target="_blank"><code>Leaflet.DistortableImage</code></a> repository, a helper module for <a href="https://github.com/publiclab/mapknitter" target="_blank"><code>Mapknitter</code></a>.</p> <p>The <code>matcher.js</code> library essentially consists of the following components.</p> <ul> <li><a href="https://github.com/publiclab/matcher-core" target="_blank"><code>matcher-core</code></a>: This module employs the <code>ORB(Oriented FAST and Rotated BRIEF)</code> algorithm to automate pattern detection using the well-known <code>FAST(Features from Accelerated Segment Test)</code> keypoint detector and the <code>BRIEF(Binary Robust Independent Elementary Features)</code> descriptor technologies, which provide appreciable performance boosts on low computational costs.</li> <li><a href="https://github.com/publiclab/matcher-cli" target="_blank"><code>matcher-cli</code></a>: A Node-based CLI utility to headlessly test custom <code>matcher-core</code> configurations, for different purposes such as testing, demonstration, debugging issues, etc, <code>matcher-cli</code> enables headless support for all of these tasks, and can easily integrate (and automate) with your choice of CI.</li> </ul> <p>This project also incorporates Public Lab's <a href="https://github.com/publiclab/Leaflet.DistortableImage" target="_blank"><code>Leaflet.DistortableImage</code></a> library overhaul for the better half of its duration. For more information, checkout <a href="https://github.com/rexagod/Leaflet.DistortableImage/commits/rexa-soc-ldi" target="_blank">this branch</a> of my fork of the same repository.</p>

javascriptruby on railswebrtc+5
Student: Pranshu Srivastava
Code

Frontend visualization and incorporation of single cell data in cBioPortal

intermediate
cBioPortal for Cancer Genomics•2024Varies175h (Medium)

My project aims to bridge the gap between single-cell gene expression data analysis and existing cancer genomics workflows, particularly within the cBioPortal platform. Currently, cBioPortal lacks support for visualizing single-cell data alongside bulk genomics data, hindering researchers from gaining a comprehensive understanding of cancer biology. To address this, I propose the development of a dedicated single-cell analysis module within cBioPortal, focusing on the MSK Spectrum dataset. The key problem I am addressing is the inability to integrate single-cell gene expression data with existing cancer genomics workflows. By incorporating single-cell data into cBioPortal, researchers will be empowered to identify specific cells with altered gene expression, understand their contribution to overall expression patterns, and connect this information with genetic alterations. My solution involves developing a custom Single-Cell Tab within cBioPortal's study view. The tab will include features such as dataset information, gene selection, interactive visualizations (boxplots, scatter plots, stacked bar graphs, and pie charts), filtering options, and download capabilities. To achieve this, I will aggregate the single-cell data to a gene-cell type-sample level, creating a pseudo bulk representation to manage the large dataset size effectively. I will utilize existing charting libraries like CanvasJS and React primitives for visualization components, ensuring seamless integration with cBioPortal's design language. My deliverables include: Custom Single-Cell Tab within cBioPortal study view. Dataset information panel for study description and cell type/sample details. Gene selection panel with autocomplete functionality. Interactive visualizations including boxplots, scatter plots, stacked bar graphs, and pie charts. Filtering options for focused data exploration. Download options for data and plots in common file formats.

javascriptjavaweb+9
Student: SURAJ SHARMA
Code

Edge-Cloud Collaborative Framework for Embodied AI Applications (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>This project aims to explore how KubeEdge can support real-world embodied AI applications, where intelligent devices such as robots, inspection systems, or autonomous mobile platforms need to perceive, process, and respond in edge environments.</p><p>The mentee will select a representative embodied AI scenario and build an end-to-end edge-cloud collaboration solution with KubeEdge. The solution should cover device or data source access, edge-side data processing, lightweight AI inference, cloud-edge synchronization, and system behavior under unstable network conditions.</p><p>Through this project, the community will gain a reproducible reference implementation that demonstrates how KubeEdge can be used as the infrastructure foundation for embodied AI workloads.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- Select a specific scenario related to embodied intelligence.</p><p>&nbsp;- Set up the KubeEdge edge-cloud environment: complete the deployment and configuration of CloudCore and EdgeCore, enable edge node access, and verify status synchronization and basic communication capabilities.</p><p>&nbsp;- Implement a closed loop for device access and edge AI inference: complete device or data source access, data collection, device status modeling, deployment of edge-side AI inference services, and inference result reporting.</p><p>&nbsp;- Verify edge-cloud collaboration and edge autonomy: implement cloud-side model delivery, configuration updates, and data aggregation, and verify continuous edge operation and recovery synchronization under weak network or disconnected scenarios.</p><p>&nbsp;- Provide reproducible engineering assets and evaluation documents, including architecture diagrams, KubeEdge configuration files, deployment and validation scripts, sample data, running instructions, and performance and reliability evaluation reports.</p><p><br></p>

TBA
Proposal
Showing 4681 - 4704 of 4718 Projects
194195196197
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal