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

Expansion of Examples and Documentation of Intermediate and Advanced Autograding Features

advanced
Submitty•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 →
350h (Large)

Instructors face significant challenges when configuring autograding systems for their courses due to limited examples, insufficient documentation, and a lack of coverage for various features. To address these issues, I propose a comprehensive solution aimed at reducing the learning curve for instructors and enhancing the functionality of autograding systems. The project focuses on three primary areas: Firstly, I aim to improve autograding examples by creating tailored solutions for specific use cases, such as evaluating compilation speed and handling distributed/networked applications. These examples will feature detailed configurations in config.json, accompanied by comprehensive documentation. Additionally, existing examples will be revamped to meet current standards and encompass a broader range of programming languages and features. Secondly, I will enhance documentation and provide illustrative examples for new autograding features that lack proper guidance. Through thorough research and collaboration with mentors, I will develop demonstrations for features like generating random input/output and utilizing customized Docker containers. The aim is to facilitate understanding and usage of these features by instructors. Lastly, to provide instructors with a user-friendly platform for configuring autograding across various educational levels, I will establish a structured repository. This repository will house a diverse array of autograding examples organized by educational level, ranging from introductory to advanced courses. Furthermore, I will encourage crowd-sourced contributions to create a comprehensive collection of programming assignments and exercises, complete with their autograding configurations. To streamline the contribution process and ensure consistency in configurations, I will implement GitHub Workflow Actions. The repository will include detailed documentation and guidelines to facilitate contribution and usage.

pythonc++databases+5
Student: Nithish Reddy Banda
Code
Proposal

Behavioral evals, Quality, and the OSS Community

advanced
Gemini CLI•2026Varies350h (Large)

This proposal focuses on improving the behavioral evaluation (eval) infrastructure of Gemini CLI to ensure reliable and safe AI tool usage. The current system has significant gaps, including missing eval coverage for ~37.5% of tools, a large number of non-CI-blocking (flaky) tests, and lack of tooling for debugging and contributing to evals. To address this, the proposal introduces a three-part approach: Expand and Stabilize Behavioral Evals Write 15–20 new evals covering uncovered tools and missing behaviors (error recovery, multi-step reasoning, safety, ambiguity handling). Stabilize flaky evals and promote reliable ones to CI-blocking status. Focus on testing tool-call decisions instead of text output for robustness. Enable Contributor Participation via Skills & Subagents Introduce an eval-writer skill to help generate evals. Build subagents like eval_investigator (debugging failures) and quality_analyst (coverage analysis). Make eval development accessible to open-source contributors. Fix Ecosystem Gaps (Process, Tooling, Documentation) Define clear eval review, promotion, and regression-handling processes. Improve logging with readable tool-call traces. Create the Eval Development Kit (EDK) with tools for: Eval inventory & coverage analysis Validation checks Auto-generating evals from real chat logs Add documentation, tutorials, and GitHub automation for easier community contributions. Overall, the goal is to transform evals from a limited internal system into a scalable, contributor-friendly quality framework, enabling the OSS community to actively improve AI behavior, reliability, and performance.

typescriptGenAIMCP+2
Student: VedantxMahajan
Code
Proposal

Persistent Device Claims for KubeVirt

intermediate
KubeVirt•2024Varies175h (Medium)

Dynamic Resource Allocation (DRA) is a new feature introduced in Kubernetes version 1.26 and above, providing an Alpha API that allows users to define Kubernetes objects similar to the Persistent Volumes API for generic resources. With DRA, users can separate the declaration of a resource to be consumed from its actual consumption. This move away from the limited "countable" API provided by device plugins allows for a more flexible control over which resources are consumed and where they are allocated. For handling host devices, KubeVirt relies on the Kubernetes device plugin framework, which is crucial for scheduling, allocating, and attaching desired devices and resources to running pods. One limitation of this framework is the lack of persistence in device allocation when the pod is not running. The proposed solution involves implementing the DRA plugin in KubeVirt for PCI passthrough (with Nvme devices as a Proof of Concept). A DRA driver typically consists of two separate but coordinating components: a centralized controller and a node-local kubelet plugin. The kube-scheduler communicates with the centralized controller, which makes allocation decisions based on the overall cluster state and resource availability. The kubelet-plugins are responsible for discovering and advertising the node's available resources to the kubelet. Additionally, the proposed approach suggests enhancing the VirtualMachineInstance (VMI) resource to include resourceClaims under hostDevices. This way, users can create a VMI resource that references a ResourceClaim (Template) which in turn references a registered ResourceClass. KubeVirt components need to be modified to translate the resource claims in the VMI host devices into the PodSpec of the underlying Pod. Finally, the device driver would be deployed along with virt-handler as part of a DaemonSet. In summary, this approach aims to leverage the DRA capabilities to enhance host devices allocation

golanggrpc
Student: Sibasish Behera
Code
Proposal

Expanding FEniCSx electromagnetic demos

advanced
NumFOCUS•2022Varies350h (Large)

Electromagnetic devices have become ubiquitous in our lives due to their limitless applications. For designing and optimizing such devices, non-uniform and unstructured meshes are essential, due to the multiscale nature of the problem. The Finite Element Method (FEM) is well known for handling such meshes. FEniCSx is an open-source platform for solving partial differential equations with the FEM, offering high-level Python and C++ interfaces. It has become a popular choice among FEM users, especially for solid mechanic and fluid dynamic applications. However, FEniCSx has not met the same popularity for electromagnetic applications due to the lack of comprehensive demos showing how to correctly setup and solve electromagnetic partial differential equations, and therefore many researchers and engineers in this field prefer to use other (often commercial) FEM platforms. This proposal aims to solve this issue by developing extensive and accessible electromagnetic demos for a number of case studies. In particular, the work will focus on delivering at least five demos (plus tests and documentation), regarding 1) the use of complex numbers, the implementation of 2) Scattering Boundary Conditions, 3) Perfectly Matched Layers, and 4) Maxwell's equations for axisymmetric structures, and 5) the parallelization of a parameterized problem with the MPI COMM_SELF communicator. These additions will be a step towards the extensive use of FEniCSx in the electromagnetic community since they will provide working tools for real-world problems. The demos will also be a show-reel for new features of FEniCSx that have not been covered in past demos or tutorials. A long term effect of this work could be more developers involved in the FEniCSx project, more guiding feedback from end users, and promotion of open source software for electromagnetic/photonic simulations.

pythonjavascriptr+3
Student: Michele Castriotta
Code
Proposal

OSS Code Indexer for Efficient Retrieval

advanced
Keploy•2025Varies350h (Large)

Keploy - OSS Code Indexer for Efficient Retrieval. (Project-2) Problem solved - Current AI models struggle to generate high-quality Unit Tests for large codebases without a deep, structured understanding of the source code. Solution Plan- 1. I implemented code parsing using tree-sitter to create semantic chunks, preserving essential context. 2. Then generating embeddings for these chunks with Gemini, openAI, huggigface and store them in a Milvus vector database. 3. I'm utilizing HNSW indexing within Milvus for efficient semantic similarity search. 4. Then I have extracted code relationships (function calls, class inheritance etc.) and store them as a knowledge graph in Neo4j. 5. Embeddings are generated with Gemini :- https://huggingface.co/spaces/mteb/leaderboard 6. I have developed a dynamic indexing mechanism (using file watching/Git hooks, potentially enhanced by Difftastic) to keep both Milvus and Neo4j synchronized with code changes. 7. Then I build a hybrid retrieval system querying both Milvus (for semantic relevance) and Neo4j (for structural context). 8. Then I integrated this combined context into Keploy's existing Unit Test Generation (UTG) workflow, feeding it to the Gemini API for test creation. 9. Then I need further suggestion to implement an LLM-as-a-judge component to evaluate the generated tests. Deliverables:- A robust GraphRAG system integrated into Keploy. This includes codebase indexing (vector embeddings in Milvus, structural graph in Neo4j), dynamic index updates, hybrid context retrieval, and integration with the Gemini, leading to substantially improved Unit Test Generation quality and relevance for users with large or complex codebases. Thanks. Regards Sparsh.

javagolangnode+4
Student: Sparshh
Code
Proposal

Time Series Analysis in Stingray.jl

beginner
OpenAstronomy•2025$1.5k–$3.3k90h (Small)

This project enhanced Stingray.jl, the Julia-based implementation of the Stingray library for X-ray timing analysis in high-energy astrophysics. Starting from my childhood passion for astronomy, GSoC allowed me to contribute to real astronomical research tools that analyze signals from stars and X-ray telescopes. Technical Journey & Contributions: Beginning with learning Julia from scratch and understanding astronomical data formats through NASA HEASARC documentation, I implemented core functionality across multiple areas: Event Data Processing: Developed comprehensive read events functionality supporting .evt and .fits files from telescopes like NICER, including GTI (Good Time Intervals) handling, energy filtering (filter_energy), and metadata extraction. This enables astronomers to process millions of X-ray events efficiently. Light Curve Analysis: Built complete lightcurve workflows from raw telescope data to scientific plots, including creation, error handling, rebinning, and intuitive plotting recipes allowing simple plot(lc) commands. Spectral Analysis: Implemented Power Spectrum and Averaged Power Spectrum analysis for both binned and unbinned data, with multiple normalization options (Leahy, fractional, absolute) and comprehensive visualization capabilities. Cross-Spectrum Analysis: Tackled the most challenging component - Cross-Spectrum and Averaged Cross-Spectrum implementation for studying phase lags and time delays between different energy bands. This contribution includes advanced plotting for amplitude, coherence, time lag, and phase lag analysis. The project transformed my understanding from basic stargazing to sophisticated astronomical data analysis, creating tools that real astronomers will use to unlock the mysteries of the universe.

cpythonjulia+7
Student: Kashish Shrivastav
Code
Proposal

LED BADGE MAGIC

advanced
FOSSASIA•2025Varies350h (Large)

Project Title: Flutter Badge Magic App Mentors: Aditya, MarioB, cweitat Problem: The current Badge Magic app offers limited customization (fixed fonts/colors), lacks interactive features, and restricts users to basic animations and Bluetooth configurations. Additionally, platform-specific deployment and unresolved bugs hinder accessibility and user creativity. Solution: Revamp the Flutter-based app to deliver: Advanced Customization: Support multiple fonts (Google Fonts integration), hex-code color pickers, and 8 editable animation storage slots. Interactive Games: Integrate Snake and Tetris with swipe/tap controls optimized for LED displays. Scalability: Auto-adapt content for diverse LED badge sizes (e.g., 11x44 to 16x45 matrices). Firmware Upgrades: Enable "Bluetooth always-on" mode and power management for stable, energy-efficient connections. Multi-Platform Reach: Automate CI/CD pipelines (GitHub Actions) for Windows, Linux, macOS, and web builds. Deliverables: Feature Enhancements: Font/color picker, editable animation storage (8 slots). Mini-games (Snake, Tetris) with collision detection. Firmware updates for advanced badge configurations. Cross-Platform Support: CI/CD workflows for 5+ platforms/app stores. Testing: 10+ unit/integration tests (90% coverage). Documentation: User guides, API references, and Quick tutorials. Bug Fixes: Resolve existing issues for a polished user experience. Impact: Empower users to create vibrant, interactive LED displays effortlessly while ensuring seamless performance across devices and platforms.

pythonjavascriptandroid+7
Student: Vivek_singh3472
Code
Proposal

CLI v2 - VS Code Integration and Local Dev Loop Enhancement (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>The Microcks CLI (microcks-cli, written in Go) is a key part of Microcks' CI/CD story - it lets developers trigger contract tests and import artifacts from the command line and in GitHub Actions. This project goes into the developer experience layer. Today, developers must navigate to the Microcks web UI in a browser to see test results, check mock status, and diagnose import errors. There is no IDE integration, no offline validation mode, and no way to get mock results inline with the code being tested. This project builds three focused improvements that bring Microcks into the editor and the local dev loop: a VS Code extension, a local dry-run mode powered by Testcontainers, and an updated GitHub Actions output format that annotates PRs with per-operation pass/fail results.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- A VS Code extension (microcks-vscode) published to the VS Code Marketplace that connects to a running Microcks instance and shows: loaded services, mock operation status, recent test run results, and importer job logs - all inline in the editor sidebar (Like postman, thunder client)</p><p>&nbsp;- A microcks test --dry-run flag in the CLI that uses Testcontainers (the Microcks uber image) to spin up an ephemeral local Microcks instance, import the specified artifact, run the contract test, report results, and tear down - with no external Microcks server required</p><p>&nbsp;- A demo video and documentation page on microcks.io showing the full local-to-CI workflow</p><p><br></p>

TBA
Proposal

Building an Advanced Flutter-Based Drawing Canvas for Magic ePaper Badge Customization

advanced
FOSSASIA•2025Varies350h (Large)

This project aims to deliver a fully-featured, cross-platform canvas-based editor for the Magic ePaper Badge, built entirely in Flutter without relying on third-party libraries. The application empowers users to create intricate badge designs with a highly customizable interface tailored specifically for ePaper screens, supporting tri-color rendering (red, white, black) and precise editing controls. Key features include a custom drawing canvas with gesture-based freehand and line drawing tools, a text overlay system with support for font selection, scaling, rotation, and locking, and an image import module allowing for multi-image manipulation on the canvas. A layer manager provides real-time reordering of image and text overlays, mirroring professional design software like Photoshop. A polished preview and export pipeline ensures clean final renders. Users can crop and adjust the final image with brightness and contrast controls before exporting it at the badge’s native resolution (240x416). The result is optimized for both BWR and BW UC8252 display variants. The project also includes robust NFC integration. I resolved critical issues in the original codebase, such as improper handling when NFC was disabled. I implemented a native Android method that navigates directly to the system’s NFC settings screen, significantly improving UX and cross-device reliability. The app now ensures seamless transmission of finalized designs to the ePaper badge over NFC. By implementing all functionality from scratch, this project delivers a performance-optimized, extensible editor tailored for the Magic ePaper Badge ecosystem, advancing FOSSASIA’s vision of accessible, user-driven customization tools.

pythonjavascriptandroid+7
Student: Dhruv Rastogi
Code

Apache SkyWalking Natural Language to BydbQL

advanced
Apache Software Foundation•2026Varies350h (Large)

This solution addresses the problem that BanyanDB / BydbQL has a high usability barrier, making it difficult for users to accurately translate natural language queries into executable query statements. In real-world observability and operations scenarios, users often lack deep understanding of query syntax, schema structures, and query patterns, resulting in low efficiency and high error rates. To solve this, the proposal designs and implements an NL2BydbQL intelligent query agent. Leveraging large language models and the LangGraph reasoning framework, the agent converts natural language into executable BydbQL. The system combines RAG (grammar rules, few-shot examples, schema semantics), MCP-based real-time schema awareness, and a multi-stage reasoning pipeline to form a complete loop from intent understanding to query generation and validation. The core approach includes: Building a structured knowledge system (Grammar Rules, Few-shot Examples, Schema Semantic Docs) Designing a dual-path reasoning mechanism (QA vs. Workflow) with dynamic routing based on query complexity Introducing an intermediate representation (IR) to unify generation and repair Ensuring query correctness via parser validation and automatic repair Incorporating runtime feedback and session memory for continuous improvement The deliverables include: A production-ready NL2BydbQL agent (based on LangGraph) A set of structured RAG datasets (grammar, examples, schema descriptions) A complete and extensible reasoning workflow design End-to-end capabilities including query generation, auto-correction, clarification interaction, and execution feedback loop This solution significantly lowers the query barrier and improves the usability and efficiency of SkyWalking and BanyanDB in intelligent operations scenarios.

pythonjavascriptjava+7
Student: Jingyi Qu
Code
Proposal

Adding PaaS support to Brooklyn

intermediate
Apache Software Foundation•2016Varies175h (Medium)

<p>The Apache open-source-project <a href="https://brooklyn.apache.org/" target="_blank">Brooklyn</a> is a multi- cloud application management platform. Brooklyn can manage the provisioning and deployment of cloud applications, can monitor applications’ health and metrics, and handle the dependencies between components. It enables cross-computing features through a unified API built over <a href="https://jclouds.apache.org/" target="_blank">jClouds</a> to manage IaaS services offered by various providers. The tool offers a REST API and a GUI that enables a single-click deployment of applications across multiple machines, locations and clouds.</p> <p>As it was aforementioned, Brooklyn provides an API for the management of IaaS cloud services and ssh resources for a great number of providers and establishes a lifecycle for the management of services and applications. This project propose to extend this API with facilities for the management of PaaS offerings such as <a href="https://cloud.google.com/appengine/docs" target="_blank">Google App Engine</a>, <a href="http://aws.amazon.com/" target="_blank">AWS services</a>, <a href="https://www.heroku.com/" target="_blank">Heroku</a>, <a href="https://www.cloudfoundry.org/" target="_blank">CloudFoundry</a> (such as <a href="https://run.pivotal.io/" target="_blank">Pivotal</a> or <a href="https://console.ng.bluemix.net/" target="_blank">Bluemix</a>) , <a href="https://www.openshift.com/" target="_blank">Openshift</a>, etc., providing an homogeneous access to IaaS and PaaS services. Moreover, it opens up some interesting proposal such as adding new technologies support, e.g., Python, PHP and adding new management policies in order to take advantage of PaaS features.</p>

pythonjavascriptjava+7
Student: Jose Carrasco Mora
Code
Proposal

API Security Assessment and Penetration Testing for Mifos Payment Hub EE

intermediate
The Mifos Initiative•2026Varies175h (Medium)

Mifos Payment Hub EE is a payment orchestration engine that coordinates and routes payment transactions among core banking systems, switches, wallets, and external financial partners. The Payment hub exposes multiple APIs for payment initiation, status queries, partner integrations, and operational management, creating a large surface area for critical risks such as Broken or inconsistent authorisation across endpoints, replay or duplicate payment requests. This project will focus on conducting a comprehensive API security assessment of the Payment Hub API, with emphasis on the OWASP API Security Top 10 and real-world payment threat models. The goal is to identify, document, and help mitigate security vulnerabilities within the system’s RESTful APIs. This project will be centred mainly around: - API Surface Mapping, which deals with enumerating the APIs found in the PaymentHub and identifying the authentication flows, request headers and partner-specific parameters used. - Threat modelling deals with mapping the threats found to the OWASP category - API Penetration Testing focused on the OWASP API Security Top 10 - Tooling and Automation, dealing with developing custom scripts and reusable test cases - Reporting and Remediation, dealing with producing a detailed vulnerability report and providing fixes and mitigation to the different vulnerabilities found. By the end of the project, the following deliverables are expected: 1) A documented Payment Hub EE API threat model and API Penetration testing checklist 2) An automated or semi-automated API security test suite for reusing in other projects 3) A detailed vulnerability assessment report with remediation guidance will be provided to help developers make patches when needed and follow secure API Practices.

mysqljavascriptandroid+5
Student: Ruphine Kengne
Code

Support arm64 Guarded Control Stack (GCS)

intermediate
CRIU•2025$3k–$6.6k175h (Medium)

This project aims to enable testing of Guarded Control Stack (GCS) functionality within CRIU (Checkpoint/Restore In Userspace) on AArch64 by integrating the Armv9.4-A GCS feature into CRIU’s ZDTM test suite through a dedicated test case that confirms whether TPIDR2_EL0 is preserved and still readable in user space after restore. The project leverages recent upstream additions to glibc and Linux kernel that enable GCS support in user space, using Yocto and Arm's Fixed Virtual Platform (FVP) to emulate and test the architecture-specific functionality. This is a first step in exploring how CRIU might need to change to handle GCS systems, starting with test coverage Project Deliverables June 2 (coding begins) - GCS-enabled Environment Verified. Yocto + FVP setup is confirmed working. Compiling and running GCS-marked binaries with glibc tunables active. July 12-16 (Midterm Evaluation) - First GCS ZDTM test added. A basic test that reads verifies TPIDR2_EL0, and explores stack/register consistency across the restore boundary. Integration with --nocr working. Investigation of parasite.c and restorer.c to identify the point at which TLS or control state (e.g., TPIDR2_EL0) could be saved or restored. August 16-August 23 (Final Evaluation) - Full round-trip test of checkpointing and restoring a GCS-using process. All tunables, toolchain flags, and kernel glibc dependencies documented. August 31 (Final Results Announced) - Final cleanup and documentation. Tutorial-style instructions provided on how to replicate setup, test flow, and next steps. Post GSOC - I will remain available to support further maintenance, and help any future contributors pick up.

clinuxassembly+3
Student: Igor Svilenkov Bozic
Code
Proposal

Design and implementation of lifecycle management of the CyberShuttle agents

beginner
Apache Software Foundation•2023Varies90h (Small)

Apache Airavata MFT is a distributed high-performance, multi-protocol data transfer engine to orchestrate data movement and operations across most cloud and on-premises storages. Agent is the core of this distributed system which does the heavy lifting of transfer jobs. Right now, agents have to be manually deploy and configure to start the transfer. This is a problem for researchers and people who need to transfer data without having much technical skills or time. Updated Proposal Summary: Updated proposal includes creating a desktop application and cybershuttle server to orchestrate the lifecycle management. This will guide cybershuttle agent and MFT agent from cybershuttle server to perform execution of jobs and data transfer, this would also maintain the lifecycle of cybershuttle agent and mft agents. This would help deploy any software and not limited to MFT agents. The proposed solution is to automate the process of deploying and lifecycle management of the agents when a transfer job is submitted from an edge machine. This will help various researchers and people who needs to transfer data from a source to a destination without having much technical skills or time. The deliverables are a piece of code to deploy the agent on various virtual machines, a piece of code to maintain the agent's lifecycle, an automated process for deployment and management, onboarding users and evaluating edge cases, and automated agent placement. The benefits of the proposed solution are that it will make it easy and on the go solution for people even with less technical ability to use the vast speeds and advantages MFT offers. It will save time and effort for researchers and people who need to transfer data from a source to destination. It will make the MFT more user-friendly and accessible to a wider range of people. It not just stops at MFT, in fact users can deploy any containerizable applications using this solution.

pythonjavascriptjava+7
Student: Praneeth Chityala
Code

AI Evaluations using Gemini APIs

advanced
Google DeepMind•2025Varies350h (Large)

Current manual evaluation methods for LLM-based AI applications are unsustainable and resource-intensive. While using LLMs as judges offers a promising alternative, evaluation frameworks provide structured tools that harness LLMs for automated assessments, offering metrics, benchmarks, and scalable testing methodologies that overcome manual evaluation limitations. Gemini's integration with evaluation platforms lacks comprehensive documentation compared to providers like OpenAI and Anthropic. Analysis of ten major frameworks reveals scattered integration, decentralized documentation, and limited implementation guidance for Gemini, creating barriers for developers and researchers. I propose a three-pronged approach to improve Gemini support across evaluation frameworks. First, adding native Gemini support to select frameworks (DeepEval and TruLens) that already offer direct integrations for other providers. Second, enhancing both abstraction-layer and framework-specific documentation, covering API key management, model configuration, and multimodal capabilities. Third, creating framework-specific guides in Python and TypeScript that demonstrate effective combination of library features with Gemini APIs. For code deliverables, I will develop native Gemini integration for DeepEval and TruLens frameworks, with pull requests submitted to respective GitHub repositories. Documentation deliverables include enhanced guidance for abstraction layers (LiteLLM, LangChain, LlamaIndex) focused on Gemini configuration, and framework-specific documentation covering API management, configuration options, multimodal integration, and evaluation best practices. Tutorial deliverables will include comprehensive guides for all ten analyzed frameworks, with Python implementations for all frameworks and TypeScript for supported ones, step-by-step configuration instructions, advanced usage examples highlighting Gemini's multimodal capabilities, and error handling techniques.

pythonjavascripttypescript+2
Student: Siddharth Sahu
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

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

It's Urgent

intermediate
CCExtractor Development•2024Varies175h (Medium)

It’s Urgent Project is a notification app, with the twist that allows the user trying to reach out decide how urgent it is (i.e. if they want to disrupt or not). It is not a messaging app or a phone app. Intuition behind the project: Have you ever had to get in touch with someone at all costs even if that meant disrupting whatever they were doing? Of course they can make you a priority contact that always rings, but then you would be disrupting every time. So that doesn't work. Deliverables: User Authentication and Management: Account creation, sign-in, and sign-out functionality. Adding other users who are currently on the app. SMS invite functionality for user referrals & Account deletion option. Notification System: Implement the Notification system with Do-Not-Disturb Mode & other checks along with Challenge mechanism. User Interface (UI) Implementation: Intuitive UI design adhering to material design guidelines. Consistent design elements and smooth navigation between app sections. Good Documentation: Technical articles explaining the app's functionality and implementation details. Updated README with project details, setup guide, and contribution guidelines. Testing (Unit, Widget & Integration): Comprehensive testing for different scenarios to ensure app reliability. Unit tests for individual components, widget tests for UI elements, and integration tests for overall functionality. Timeline & Plan of Action: Phase 0 (May 1 - 26): Community Bonding Period, UI Design, Repository Setup. Phase 1 (May 27 - Jun 16): User Authentication Implementation. Phase 2 (Jun 17 - Jul 7): Notification System Development. Midterm Evaluation (Jul 8 - 14): Mid Evaluation. Phase 3 (Jul 15 - Aug 4): UI Enhancement, Testing, and Documentation. Phase 4 (Aug 5 - 25): Refactoring, Final Testing, and Evaluation.

clinuxvideo+14
Student: 0xharkirat
Code
Proposal

Add Tinkerbell to Headlamp - Bare Metal Provisioning UI (2026 Term 2)

Intermediate
•Varies175h (Medium)

<p>[Tinkerbell ](https://tinkerbell.org/) is a CNCF sandbox project and a flexible bare metal provisioning engine that enables operators to provision and manage physical hardware using Kubernetes-style declarative workflows.&nbsp;&nbsp;</p><p>&nbsp;This project builds a Headlamp plugin that adds a **Tinkerbell** section to Headlamp, surfacing Tinkerbell CRDs and resources so operators can view and manage hardware, workflows, and templates directly from the Headlamp UI.&nbsp;It follows Headlamp UX patterns with list and detail views, resource relationships, and optional workflow status visualization to make bare metal operations easier to understand and control.</p><p>- Expected Outcome:</p><p>&nbsp;- Plugin exposes key Tinkerbell CRDs: Hardware, Workflow, Template, and related resources.</p><p>&nbsp;- List views, with summary columns (name, namespace, hardware state, workflow status, last action).</p><p>&nbsp;- Detail pages, showing spec/config, status, workflow steps, execution logs, and associated hardware.</p><p>&nbsp;- Workflow visualization, showing steps and current execution state of provisioning pipelines.</p><p>&nbsp;- Relational navigation, hardware → workflows; workflow → templates and actions.</p><p>&nbsp;- Consistent Headlamp UX, icons, tables, detail layouts, Map view enhancements for hardware resources.</p><p>&nbsp;- Structured config display (collapsible sections/YAML toggle), humanized statuses, and safe action triggers (e.g. retry workflow).</p><p>&nbsp;- README with prerequisites and limitations; blog post demoing bare metal provisioning workflows in Headlamp.</p><p><br></p>

TBA
Proposal

OpenCRE Noise & Relevance Filtering Pipeline

advanced
OWASP Foundation•2026Varies350h (Large)

This project addresses the challenge of distinguishing meaningful security knowledge from noisy or irrelevant changes in OWASP repositories. Currently, large volumes of repository updates include formatting changes, test files, and administrative edits, which dilute the quality of extracted knowledge and reduce the efficiency of downstream systems. To solve this, I propose building a two-stage intelligent filtering pipeline within the OpenCRE Scraper & Indexer framework. The first stage uses regex-based rule filtering to eliminate obvious noise (e.g., non-informative files and structural changes), ensuring low-cost, high-speed preprocessing. The second stage applies LLM-based semantic classification (via models like GPT-4o-mini or Gemini Flash) to determine whether a change introduces genuine security knowledge, such as new vulnerabilities, attack techniques, or mitigation strategies. This hybrid approach balances efficiency with deep contextual understanding. The system will be integrated into the OpenCRE pipeline, forwarding only relevant outputs into a knowledge queue for further processing. It will include structured logging, prompt optimization, cost-efficient API usage, and robust evaluation based on precision, recall, and accuracy. Deliverables include: 1. A production-ready two-stage filtering pipeline (regex + LLM) 2. Integration with the OpenCRE knowledge ingestion workflow 3. A labeled evaluation dataset and performance benchmarks (targeting high accuracy and recall) 4. Unit-tested, scalable, and well-documented codebase 5. Detailed documentation on prompt engineering, system design, and evaluation methodology This project will significantly improve the quality, reliability, and scalability of security knowledge extraction, enabling the OWASP community to focus on high-value insights while reducing noise in the ecosystem.

pythonjavascriptjava+10
Student: Manshu Saini
Code
Proposal

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

Improving AI Data Pipelines in AIDRIN: A Privacy-Centric and Multimodal Expansion

intermediate
UC OSPO•2025Varies175h (Medium)

AIDRIN (AI Data Readiness INspector) is an open-source tool designed to assess the quality, fairness, and readiness of datasets before they are used in AI workflows. However, its current implementation supports only basic evaluations for tabular data and lacks both privacy-aware assessments and the ability to handle unstructured data formats like images. This project proposes to address these limitations in two structured phases. In Phase 1, I will enhance AIDRIN’s capabilities for tabular datasets by implementing essential privacy-preserving metrics—such as k-Anonymity, l-Diversity, t-Closeness, MM Risk Score, and Entropy-Based Disclosure Risk—alongside other key checks for class imbalance, feature correlation, and model evaluation. These assessments will be supported by intuitive visualizations to help users make informed decisions about data quality and compliance. In Phase 2, I will extend AIDRIN to support image datasets by integrating pretrained vision models to generate semantic embeddings. These embeddings will enable readiness evaluations such as duplicate and outlier detection, class imbalance analysis, completeness checks, and fairness diagnostics (when label or attribute metadata is available). The goal is to replicate AIDRIN’s structured readiness evaluation pipeline for visual data in a modular and reusable manner. Deliverables include: Privacy and imbalance metric suite for tabular data with visual summaries Embedding-based readiness evaluation pipeline for image datasets Integration with pretrained vision models (ViT, CLIP, DINOv2) CLI tool for executing and exporting assessment results Documentation, testing, and demonstration notebooks By the end of the program, AIDRIN will support robust and privacy-aware readiness assessments for both structured and unstructured datasets, helping researchers and practitioners build more transparent, reliable, and ethical AI systems.

pythonc/c++visualization+5
Student: Harish Balaji
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

Public Courses on github

intermediate
omegaUp•2025Varies175h (Medium)

The proposal outlines a project to migrate the management of omegaUp's public courses to GitHub, enabling open-source contributions and improving collaboration, version control, and deployment consistency. Currently, omegaUp's public courses are managed manually, which can be time-consuming and lacks community involvement. By using GitHub, contributors can submit pull requests (PRs) to update course content, which will be automatically validated and deployed using GitHub Actions and omegaUp's API. Key components of the project include: 1. Course Migration: All public courses will be uploaded to a GitHub repository, structured by course and content type (lectures, problems, etc.). 2. CI/CD Workflow: A GitHub Actions pipeline will validate and deploy updates when a PR is merged. This pipeline will automatically check for any changes in problems and deploy only the modified content. 3. API Integration: The system will use omegaUp’s API to upload content after successful review and approval of changes. 4. Community Collaboration: Contributors can suggest improvements via PRs, with a review process ensuring quality control before deployment. 5. Automated Testing: The CI/CD pipeline will run validation scripts to check metadata, problem structure, and other course details before deployment. 6. Security: A review and approval mechanism will prevent unauthorized or malicious content from being deployed. The project aims to enhance omegaUp’s educational content by leveraging GitHub’s collaboration model, ensuring faster updates, better quality control, and reduced manual workload for omegaUp staff. A proof of concept has been set up in a sample GitHub repository, where contributors can simulate the entire workflow by submitting PRs and seeing automatic deployments on omegaUp. This approach is expected to streamline course management, making it scalable and more responsive to community-driven improvements.

pythonmysqlphp+2
Student: Anas Iqbal
Code
Proposal
Showing 3841 - 3864 of 3883 Projects
159160161162
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal