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

Jaeger for GenAI Observability: Specialized Trace Visualization (2026 Term 2)

Intermediate
•Varies

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)

<p>Distributed tracing is essential for GenAI observability, but observing AI Agents differs fundamentally from observing microservices. While microservice traces focus on network latency and error codes, AI traces focus on the "reasoning process." The current Jaeger UI displays traces in a standard waterfall timeline, making it difficult to distinguish between logical "Tool Calls" and technical operations, and nearly impossible to read multi-paragraph prompts or view generated images. This project aims to transform the Jaeger UI into a first-class GenAI observability tool. When Jaeger detects a trace containing GenAI-specific metadata (following OpenTelemetry semantic conventions), it should automatically adapt its presentation to prioritize the "Agentic Flow."</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Automatic "GenAI Mode" detection: detect `gen_ai.*` attributes and offer/switch to a specialized visualization mode</li><li>Agentic hierarchy with iconography: use distinct icons to differentiate span types (e.g., "brain" for LLM calls, "wrench" for tool calls, "database" for RAG retrieval)</li><li>Rich-media side panel leveraging ADR-0006 side-panel capability, with Markdown support for prompts and completions, pretty-printed JSON for tool inputs/outputs, and direct rendering of images/audio previews</li><li>Simplified "logical" view: toggle to hide infrastructure-level noise and reveal a clean, high-level reasoning flow</li><li>More compact table view of multiple traces on the Search page</li></ul>

TBA
Proposal

Mifos X Smart Contract & Loan Agreement Summarization with LLMs

intermediate
The Mifos Initiative•2026$3k–$6.6k175h (Medium)

Loan agreements are supposed to protect borrowers. In practice, most people sign them without understanding what they say, not because they're careless, but because these documents are written in language that takes training to parse. For the rural borrowers and small business owners that Mifos X was built to serve, this gap is not a minor inconvenience. It is a direct risk to their financial wellbeing. This project builds an LLM-powered summarization layer that integrates directly into Mifos X. A loan officer pastes a contract or pulls a loan product from Mifos X via the Fineract REST API, and the system extracts every key financial term like loan amount, interest rate, repayment schedule, every fee. It runs a mathematical consistency check on the numbers, and returns a plain-language summary written so anyone can understand it before they sign. Every extracted value is verified against the source text before reaching the screen, so the tool never silently surfaces wrong information. For MFIs with strict data privacy requirements, the system supports fully local inference via Ollama, no borrower data ever leaves their server. Before writing this proposal I built a working POC, deployed at https://loan-analyzer.streamlit.app/ , to prove the core pipeline actually works on real contracts. That POC is the foundation. The GSoC project takes it from a proof of concept into a properly integrated Mifos tool, with three deliverables: a working application connected to Mifos X with summaries generated in under ten seconds; a documented LLM evaluation comparing four providers on accuracy, readability, speed, and cost submitted to the Mifos wiki; and a clean codebase any contributor can clone and run in under fifteen minutes.

mysqljavascriptandroid+5
Student: Silky Vyas
Code

Implementation of the RISC-V ISA Extensions for Control-Flow Integrity Mentorship Project

Intermediate
•Varies175h (Medium)

<p>Control-flow integrity (CFI) is a fundamental security mechanism that prevents attackers from hijacking a program's execution flow. By exploiting memory vulnerabilities, such as stack-smashing or use-after-free bugs, malicious attackers can corrupt pointers or overwrite return addresses, thereby silently redirecting execution to arbitrary malicious code. RISC-V has recently ratified two ISA extensions to enforce CFI at the hardware level through two complementary primitives. The shadow stack maintains a separate, hardware-protected copy of return addresses, preventing a corrupted call stack from redirecting returns to malicious code. Landing pads require that all valid indirect jumps must land at an explicitly marked location with a special instruction, preventing attackers from redirecting execution to unintended locations.</p><p><br></p><p>In collaboration between the Barcelona Supercomputing Center (BSC) and the SUSHI research team (Inria Rennes), this project aims to implement both CFI extensions on Sargantana, an open-source, Linux-capable, RISC-V core. The mentees will begin by studying the RISC-V CFI specification and the Sargantana microarchitecture, and will then produce an architectural plan of the required pipeline modifications. The mentee will then implement the shadow stack mechanism, including hardware enforcement of shadow stack semantics and access-protection logic. This will be followed by landing pad support, which will involve pipeline enhancements to validate indirect branch targets at commit time. Finally, the mentee will use the Sargantana emulation infrastructure to ensure functional correctness of the implemented extensions and to study the hardware overhead they impose.</p>

TBA
Proposal

Apache Arrow Interface for PODIO

advanced
CERN-HSF•2026Varies350h (Large)

This project aims to implement a high-performance Apache Arrow backend for PODIO. Currently, PODIO data is primarily persistent in ROOT and SIO formats, which can introduce significant I/O overhead for modern, language-independent analytics. The Problem In high-energy physics, data analysis often requires processing only specific subsets of complex event structures. Traditional file-based backends often require loading entire object hierarchies, leading to memory and I/O bottlenecks. The Solution The proposed solution implements a dual-path ingestion strategy within PODIO's code generation engine In-Memory Zero-Copy Access: Utilizing arrow::ListView to map existing PODIO memory buffers directly into Arrow tables for real-time, language-independent analysis. Serialized Normalization: Implementing a normalization layer that packs scattered memory blocks into contiguous arrow::ListArray structures to satisfy the strict requirements of Parquet storage. Relational Mapping: Resolving C++ pointers into a Composite Key (Collection ID + Index) to maintain complex object relationships across different platforms and memory layouts. Key Deliverables Core Arrow Backend: A C++ implementation integrated into PODIO's generator to translate YAML-defined models into Arrow’s columnar format. Parquet Support: Out-of-the-box serialization to industry-standard Parquet files. Round-Trip Validation: A robust testing suite ensuring 100% data parity when converting between PODIO Frames and Arrow Tables. Performance Benchmarking: A side-by-side comparison of throughput and disk footprints between ROOT TTree and the new Arrow/Parquet backend.

pythonc/c++machine learning+6
Student: Arnav Dham
Code
Proposal

A Seamless Interface Between LLMs and Pharo

advanced
Pharo Consortium•2025Varies350h (Large)

This project aims to build ChatPharo, an intelligent, AI-powered assistant that integrates Large Language Models (LLMs) directly into the Pharo development environment. Despite Pharo’s strengths as a live programming platform, it currently lacks a native and user-friendly interface for interacting with LLMs to assist with code explanation, generation, documentation, and debugging. To address this, the project proposes a seamless, modular, and extensible system that connects Pharo with both online (OpenAI, DeepSeek) and offline (TinyLLaMA, Mistral-7B via Ollama) models. A multi-tab chat interface will allow users to manage multiple contextual conversations, while intelligent AI commands (e.g., /explain, /generate tests, /refactor) will directly support day-to-day coding workflows. Memory optimization techniques—including smart caching, chat pruning, and lazy model loading—will ensure smooth performance even in long sessions. A key innovation includes experimenting with pseudo-parallelism in Pharo’s single-threaded architecture by spawning secondary images to offload heavy LLM processing. This enables parallel task handling without compromising the responsiveness of the main Pharo image. By midterm, users will have access to a working chat UI, multi-LLM switching, and foundational coding actions. By the final evaluation, ChatPharo will evolve into a context-aware assistant capable of inline suggestions, AI-driven debugging, and scalable architecture for future extensions. Through full documentation, tutorials, and community engagement, this project will not only enhance developer productivity but also showcase Pharo as a capable, modern AI-enhanced development platform.

smalltalkroassalpolymath+7
Student: SrajalDwivedi17
Code
Proposal

Gemma Scout: On-device AI camping & wildlife survival companion

advanced
Google DeepMind•2025Varies350h (Large)

About 88 million U.S. households now identify as campers, and ~54 million households took a trip last year National parks run thousands of search-and-rescue operations every year (e.g., ~3,400 in 2022), and research shows tens of thousands of people were lost in parks over the 2004–2014 decade. First aid, navigation, shelter, and water skills reduce risk and help you protect others. That’s why I built Gemma Scout: an on-device, privacy-first AI assistant built for wilderness survival and outdoor adventures. Powered by a finetuned version of Gemma 3N, it combines domain-specific survival knowledge with real-time multimodal reasoning to guide users through critical tasks like plant identification, mushroom safety, shelter building, and first aid. The model was trained on over 30 million tokens and 7,618 curated Q&A pairs, sourced from expert handbooks and image datasets of edible plants and mushrooms. Leveraging Unsloth’s optimized finetuning framework with LoRA and quantization, Gemma Scout runs efficiently on mobile devices without internet access. Using LLM evaluations, Gemma Scout outperformed its base model in survival QA by a win rate of 89%, and achieved over 36% improvement in mushroom classification and 47% in plant identification. It supports multimodal chat via llama.cpp mtmd and Swift integration, enabling users to send images and receive grounded, expert-level responses—completely serverless. Whether you're camping, hiking, or lost in the wild, Gemma Scout helps you make smart, safe decisions—even when you're off the grid.

pythonjavascripttypescript+2
Student: Ryan Rong
Code

3D PDF Export in FreeCAD

advanced
FreeCAD•2025Varies350h (Large)

The 3D PDF Export for FreeCAD project aims to develop a native capability for exporting interactive 3D models directly to PDF format, enhancing FreeCAD's documentation and collaboration capabilities. Currently, FreeCAD users must rely on complex multi-step workflows involving external tools like MeshLab, LaTeX, or even commercial CAD software to create 3D PDFs, often resulting in loss of model fidelity, colors, and structure. This project proposes implementing a seamless 3D PDF export feature integrated directly into FreeCAD's TechDraw workbench. Users will be able to create standard technical drawings with traditional orthographic views and dimensions, plus an interactive 3D view that appears as a regular isometric view in print but becomes fully interactive when viewed digitally. Key components of the implementation include: 1. Document Structure Access: Utilizing FreeCAD's Python API to traverse the document object hierarchy or need to rely on Qt for accessing certain structural information. 2. 3D Format Conversion: Implementing exporters for both U3D format and PRC format to support NURBS surfaces for higher fidelity representation. 3. PDF Generation: Creating a PDF container that properly embeds the 3D content with interactive viewing capabilities. 4. TechDraw Integration: Extending the TechDraw workbench to include a new "3D View" type alongside traditional orthographic views. The completed feature will significantly enhance FreeCAD's usability for professional documentation, enabling users to share interactive 3D models with clients and collaborators who don't have CAD software, addressing a long-requested feature within the FreeCAD community.

pythonc++qt+2
Student: chiragsingh1711
Code
Proposal

BI connector and demonstration

intermediate
Apache Software Foundation•2026$3k–$6.6k175h (Medium)

Fineract is largely used as a system of record for lending in many institutions globally. As such, most of the analysis is about portfolio health — how well are people paying back, and what are the key risks around repayments. This includes PAR, loan loss provisioning, write-offs, and trend lines for the same, along with basic stats like number of customers, the loan cycle they are on, aging of customer cycles, exceptions tracking, and correlation to any characteristic in the data. Currently Fineract does not have a analytics pipeline where vendors, users, institution can see these analytics. This project solves this problem. My plan is to build a complete ELT analytics platform. A python extractor will pull data from read replica of Fineract DB incrementally using a read only database user. It will push the data the PostgreSQL analytics warehouse. From there a dbt project will handle all the data transformation (delinquency calculations, PAR ratios, repayment behavior, portfolio health). I will show interactive dashboards with different type of charts, graphs, stats and analytics using Apache Superset. By the end of GSoC, the deliverables are: a working Python ELT extractor with both backfill and incremental modes, a fully tested 4-layer dbt warehouse model covering the Fineract lending domain, five production-oriented Superset dashboards (Portfolio Health, Delinquency and PAR, Repayment Behavior, Risk and Finance, Customer Lifecycle), Docker Compose setup so anyone can run the full stack locally, and complete documentation including a runbook and data dictionary. The whole stack is Apache 2.0 licensed, self-hostable, and designed so future contributors can add new analytics modules without changing what's already there.

pythonjavascriptjava+7
Student: Aira Jena
Code
Proposal

Multi-Agent Traffic Optimization + Infrastructure improvements.

advanced
Open Robotics•2025Varies350h (Large)

I am Ryan, a college student finishing their last semester for a bachelors in computer science. My contribution to the multi-agent traffic optimization project would be to take the lessons I’ve learned from my previous bevy projects, and use them to update and improve rmf_site’s infrastructure over the course of several stages, and to use those improvements to add procedural generation for the tests sites that will then be used for multi-agent optimization testing. The stages for this would be as follows: 1. bevy 0.12 -> latest version of bevy + library updates.. 2. Compile time improvements 3. Debug tool improvements 4. test scenario automation through procedural generation. Update everything: The first thing to do would be to update rmf_site bevy and all other dependencies to their latest versions. I’ve done this for all my projects since bevy 0.11, and I can do it for rmf_site too. Improve Compile TImes: The next step would be improving compile times. When I tested this project on my local machine. Iterative compile times took around 50 seconds. With the appropriate restructuring of crates, slimmer crate imports, more granular feature flags, and the introduction of the mold linker, these recompile times could be cut down to around 2-7 seconds. Improve debug tools: After that, then comes adding more debug tools. We can add bevy_inspector_egui for bevy entity/component inspection, bevy_tracing for performance optimization via Tracy. Automate test scenarios: Lastly, would be adding procedural generation for test sites. First, would be adding initial tests with randomized prefab placement, then moving to procedural room layouts from tiles, then assigning different layout kinds to each of these, (storage room, office room, etc..), and then finally connecting these different layouts together into a single site.

pythonc/c++ros+5
Student: rydb
Code

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

Cloud-native OGC SensorThings API

intermediate
52°North Spatial Information Research GmbH•2024Varies175h (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

Mainframe Open Education – Educational Content & Advocacy Mentorship (Unpaid-2026) Mentorship Project

Intermediate
•Varies175h (Medium)

<p>The Mainframe Open Education (MOE) Project seeks a creative and enthusiastic individual to serve as a&nbsp;<strong>Mainframe Education Advocate</strong>. The primary goal of this mentorship is to champion&nbsp;<strong>peer-to-peer education</strong>: taking foundational mainframe concepts and turning them into clear, engaging, and accessible content for the student community.</p><p>The 2026 program emphasizes&nbsp;<strong>Education-as-Communication</strong>. The mentee will act as a relatable voice for the student and early-career community, documenting their own learning journey and translating foundational technical workflows into engaging, introductory-level blog series and interactive modules.</p><p><br></p><p><strong>Deliverables</strong></p><p><strong>"Mainframe 101" Blog Series:</strong>&nbsp;Create a series of 3–4 introductory blogs that break down foundational topics into easy-to-digest, interactive guides.</p><p><strong>Social Advocacy:</strong>&nbsp;Create short-form summaries of educational content to share across student-facing platforms, driving awareness of the Open Mainframe Project.</p><p><strong>Peer Collaboration:</strong>&nbsp;Work alongside the MOE Student User Group to identify the top 5 "points of confusion" for new learners and address them through content.</p><p><strong>Mentorship Journey Blog:</strong>&nbsp;A post reflecting on their experience learning within the OMP/MOE community and tips for other undergraduates looking to get started.</p><p><strong>Industry Engagement:</strong>&nbsp;Develop a session for an industry event, focusing on the importance of student-led technical documentation.</p>

TBA
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

Enhancing OpenPiton+Ariane With a High-Performance Data Cache

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

As the demand for High-Performance Computing (HPC) continues to grow, there is a need for open-source solutions that can deliver the performance required by modern applications. Different open-source architecture frameworks have been developed by the community, like OpenPiton, however, all of them present performance limitations that impact their ability to execute computationally-intensive tasks. OpenPiton is an open-source framework for designing many-core processors. Although OpenPiton was originally developed for SPARC v9 architectures, currently it is also compatible with different core architectures (RISC-V 32-bit, RISC-V 64-bit, x86, and SPARCv9). In this project, we will focus on improving the performance of the integration of CVA6/Ariane into OpenPiton (OpenPiton+Ariane). The architecture of OpenPiton consists of one chipset and one or more tiles. The chipset houses modules used to communicate the tiles with the peripherals, such as the UART. The tile is used to build the mesh for many-core designs. In these designs, the tiles are interconnected by three NoC routers to generate the mesh. Each tile comprises the three NoC routers, the Ariane core, and the cache hierarchy, which consists of Ariane’s private L1 data and instruction caches, a private L1.5 cache and a shared distributed L2 cache. Despite the fact that OpenPiton offers many advantages, it presents performance limitations that restrict its adoption in the HPC field. In this project, we will improve the performance of OpenPiton by replacing the L1 data cache of Ariane with the High-Performance, Multi-Requester, Out-of-Order, L1 data cache (HPDcache). In addition, other features such as the amount of L1.5 cache miss status holding registers (MSHRs) or the L1.5 cache associativity can also be improved in order to approach OpenPiton even closer to the HPC field.

pythonjavascriptfpga+11
Student: Noelia Oliete Escuín
Code

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

PosteriorDB Implementations for Turing.jl

beginner
The Julia Language•2024Varies90h (Small)

Benchmarking sampler implementations for Bayesian inference is hard — the algorithms are inherently stochastic, and often produce only Monte Carlo samples of some distribution of interest. As a result, Bayesian inference lags other areas of machine learning in the availability of common benchmarks. To help solve this, the Stan team put together posteriordb, described as: "a set of posteriors, i.e. Bayesian statistical models and data sets, reference implementations in probabilistic programming languages, and reference posterior inferences." (posteriordb Github readme). This proposal would add Turing implementations for most of these models, facilitating easier sampler benchmarking in Turing. This database would also serve as a set of examples of Turing best practices. The project will result in a database of 120+ varied Bayesian models written in Turing, representing translations of a database of corresponding Stan models. Regarding deliverables, the proposal pdf contains a detailed and complete schedule, directly blocking out time for 130+ of the posteriors, with some additional stretch goals included. As a summary, (1) Initial weeks are spent getting familiar with Turing best practices while building out 50+ of the simplest models (mostly, variants of Bayesian regression). (2) Weeks leading up to the midterm assessment are blocked off for GLMMs and Bayesian ODEs. (3) Weeks following the midterm assessment are dedicated to two types of discrete models — first, models with a discrete structure amenable to simply summing out the discrete components (e.g. mixture models). Second, I'll implement HMMs, which require some specific algorithms to match the Stan posteriors. (4) Chip away at remaining models that don't neatly fit into a specific category, for example, neural networks, splines, and gaussian processes. If a week ends with models incomplete, I'll move on to the next week, ensuring a varied selection of models make it into the database.

cjavascriptc+++12
Student: JasonPekos
Code
Proposal

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

MEASURING ENERGY CONSUMPTION USING REMOTE LAB

intermediate
KDE Community•2023Varies175h (Medium)

Sustainability is a key goal for KDE over the next two years. As part of this goal, KDE aims to measure the energy consumption of its software and eco-certify applications with the Blue Angel ecolabel. Currently, we measure the energy consumption of our software using a lab based in Berlin following the process documented in the KDE Eco Handbook (Handbook: Applying The Blue Angel Criteria To Free Software). The lab setup requires (i) a test PC (System Under Test) to run user-emulation scripts, (ii) a power meter to measure the energy consumption of the test PC, and (iii) another PC (Data Aggregator & Evaluator) to collect and analyze the output data. In the current setup, developers must rely on individuals in Berlin to test software for them on-site in the lab. This proposal aims to provide remote access to the lab in two steps: first, automating the energy measurement process, including providing a summary of the results; and second, setting up backend CI/CD integration for measuring energy consumption. By automating the process and providing remote access, we make it possible for developers to measure the energy consumption of their software from any location in the world. The increased access to the lab will enable data-driven decision-making for efficiency improvements in code and software eco-certification with agencies like the Blue Angel. The proposed project has three main goals: i) Measurement Automation: Implement a solution where a developer provides as input three scripts (baseline, idle mode, and standard usage scenario) with a config file and automatically obtains a summary of results from OSCAR (Open source Software Consumption Analysis in R). ii) Remote Access 1: Implement a CI/CD pipeline as a backend solution for performing the energy consumption measurements in the remote energy measurement lab.

c/c++qtqml+6
Student: Karanjot
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

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

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
Showing 5929 - 5952 of 5976 Projects
246247248249
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal