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

OWASP Web Application Honeypot - Adaptive Intelligence Platform

intermediate
OWASP Foundation•2026Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
350h (Large)

The OWASP Web Application Honeypot is the only open community project focused on the HTTP application layer, but it currently sits as a dormant proof-of-concept with an outdated logging format, no fingerprint detection, and no path to push threat data into community platforms like MISP. This proposal evolves it into a production-ready, adaptive, and intelligence-grade platform. The solution is built around 8 interconnected deliverables: 1. Versioned JSON logging schema (v1.0) with GeoIP2 and MITRE ATT&CK enrichment 2. Automated CRS version management via nightly GitHub Actions 3. CRS 4.x honeytrap plugin with hot-reload daemon (no container restart required) 4. Shodan Honeyscore-triggered chameleon engine for automatic persona rotation 5. Vulnerable application fingerprint library with 4 personas (Apache, IIS, phpMyAdmin, WordPress) 6. Multi-region AWS deployment framework using Terraform with centralised Kibana 7. MISP and STIX 2.1 threat intelligence exporters with optional TAXII push 8. Industry segment profiles for education, financial, and general deployments switchable via a single environment variable Each deliverable has measurable success criteria and risk mitigation. Built on prior production work in DICOMHawk, GreedyBear, and IntelOwl where identical problems were already solved. Total effort is 350 hours across 13 weeks.

pythonjavascriptjava+10
Student: R1sh0bh
Code
Proposal

Idea 1 : Improving Democracy’s Library

intermediate
Internet Archive•2023Varies175h (Medium)

Problem to Solve : Build a system which performs the following: Enables full-text search of documents; filtered by agency, date, views Recommends similar documents based on semantic similarity of document contents Extracts significant document features such as topics, persons, locations, etc. Clusters and sorts documents by artifact topic (i.e. aerospace, environmental, nuclear, civil rights, etc.) Including: Natural language summaries for each artifact in the collection. Solution: To build the requested system, we will need several components and technologies. Here are the basic steps to achieve the functionality we require: Data ingestion: Loading the documents from a data source and extract the relevant information such as the document ID, title, content, agency, date, and views. Full-text search: Indexing the documents in a search engine such as Elasticsearch and enable full-text search with filters on agency, date, and views. Semantic similarity: Using a natural language processing model such as Doc2Vec to calculate the semantic similarity between documents and recommend similar documents. Document feature extraction: Using a named entity recognition model such as Spacy to extract significant document features such as topics, persons, locations, etc. Clustering and sorting: Using a clustering algorithm such as KMeans to group the documents into clusters based on artifact topic and sort them accordingly. Natural language summaries: we can use a summarization algorithm such as Gensim to generate natural language summaries for each document in the collection.

pythonjavascriptpthon+6
Student: Krish Shewani
Code
Proposal

libgomp Optimizations for Scheduler Guided OpenMP Execution in Cloud VMs

advanced
GNU Compiler Collection (GCC)•2026Varies350h (Large)

Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.

cc++openmp+3
Student: Nchang Roy
Code

Mifos Gazelle - Open G2P integration

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

Mifos Gazelle currently enables rapid, single-command deployment of Mifos X, Payment Hub EE, and related Digital Public Goods (DPGs). However, there is no existing integration between Gazelle and OpenG2P - an open-source platform used by governments and humanitarian organizations to deliver social protection benefits. This gap means that developers, DPG evaluators, and governments cannot easily spin up a complete Government-to-Person (G2P) payment demonstration environment today. This project bridges that gap by investigating and implementing a full integration of OpenG2P into the Mifos Gazelle stack. The integration will adapt OpenG2P's core modules - Social Registry, Program and Beneficiary Management System (PBMS), Social Payments Account Registry (SPAR), and G2P Bridge - to run on Gazelle's based infrastructure, replacing it with lightweight, portable version targeted for pilots and demo programs. By the end of GSoC 2026, the following will be delivered: Single-command deployment: A new Gazelle profile that deploys the complete OpenG2P stack with one command (./run.sh -u $USER -m deploy -a openg2p) End-to-end demo scenario: A fully scripted Demo Creator workflow covering beneficiary registration, program enrollment, account mapping via SPAR, and payment disbursement through G2P Bridge - Payment Hub EE Documentation: A deployment guide covering prerequisites, architecture decisions, resource requirements, and step-by-step instructions

mysqljavascriptandroid+5
Student: Mohammad Gous Alam
Code
Proposal

Native Julia ODE, SDE, DAE, DDE, and (S)PDE Solvers

advanced
NumFOCUS•2026Varies350h (Large)

OrdinaryDiffEq.jl contains over 18 IMEX Runge–Kutta implementations that share identical stepping logic but have bespoke per-method perform_step! functions. This creates massive code duplication and makes adding new methods prohibitively expensive. This project builds a unified IMEXTableau{T,T2} infrastructure — one struct holding both explicit and implicit Butcher arrays, one generic perform_step! dispatching on it — so new IMEX methods require only coefficient definitions. The existing KenCarp and Kvaerno families (18 methods) are migrated to this framework, deleting ~3,300 lines of hardcoded code. New Pareschi–Russo methods from issue #2065 are added on top of the infrastructure. The second deliverable extends the multirate solver family. MREEF (Multirate Extrapolated Explicit Euler) is already implemented and approved (PR #3139). This project adds MREIL (linearly implicit variant for stiff fast components) and MIS methods (Schlegel–Knoth scheme used in atmospheric chemistry, issue #1195). Key deliverables: Generic IMEXTableau framework with one perform_step! replacing 18 implementations Migration of KenCarp/Kvaerno family with ~3,300 lines deleted Pareschi–Russo IMEX methods (issue #2065) MREIL: linearly implicit multirate extrapolation MIS methods: Schlegel–Knoth atmospheric chemistry scheme (issue #1195) Convergence tests and SciMLBenchmarks work-precision diagrams for all new methods

pythonjavascriptr+3
Student: HARSH_K
Code
Proposal

Redesigning GridWorlds.jl

beginner
The Julia Language•2021Varies90h (Small)

<p>Environments are a crucial component of <a href="https://en.wikipedia.org/wiki/Reinforcement_learning" target="_blank">reinforcement learning (RL)</a>. Grid worlds are a broad class of tile-based games that are easy to create, and are quite popular for testing and comparing various RL algorithms. They are highly versatile and provide immense flexibility in terms of creating custom environments that can test for specific properties like safe exploration, for example. <a href="https://github.com/JuliaReinforcementLearning/GridWorlds.jl" target="_blank">GridWorlds.jl</a> is a <a href="https://julialang.org/" target="_blank">Julia</a> package that provides a suite of grid world environments along with useful primitives that aid in creating custom environments.</p> <p>This project redesigns GridWorlds.jl in a way that makes it simpler, easy to understand, and more performant (in some cases) than the previous version (v0.4.0). The new version (v0.5.0) also decouples itself significantly from the API of <a href="https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl" target="_blank">ReinforcementLearning.jl</a>, which makes it easy to create entry points from other reinforcement learning frameworks. It also becomes possible to programmatically record, replay, and analyze an agent’s behavior at any point during training, which proves handy while performing reinforcement learning experiments. Moreover, one can directly play the games from GridWorlds.jl inside the Julia REPL.</p>

cjavascriptc+++12
Student: Siddharth Bhatia
Code
Proposal

Expected Returns: Factor Formation

advanced
R project for statistical computing•2025Varies350h (Large)

Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.

cc++r+4
Student: Al Pakrosnis
Code
Proposal

Carbon-Aware Local Fitness Tracker

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

During GSoC, I propose to build a carbon-aware fitness tracker application from scratch that combines personal health tracking with environmental awareness while prioritizing user privacy. The project addresses two key problems: the lack of privacy in existing fitness apps, which often rely on external servers, and the absence of tools that help users understand their daily carbon footprint. To solve this, I will develop a Flutter-based mobile application along with a Wear OS companion app, integrating them using the Data Layer API and platform channels to seamlessly transfer fitness data such as steps, heart rate, and activity metrics from the watch to the phone. On the Wear OS side, I will use the Health Services API to collect real-time data, while the mobile app will feature a transport logging system that calculates carbon emissions or savings based on user travel choices, along with a dashboard displaying weekly summaries, visual charts, and actionable sustainability suggestions. All user data will be stored locally using SQLite to ensure complete privacy, and the application will be supported by comprehensive unit, widget, and integration testing to ensure reliability. The final deliverables will include a fully functional mobile and Wear OS application, a secure local data management system, a carbon footprint tracking and visualization module, and a production-ready app prepared for deployment on Android and Wear OS platforms.

pythonjavascriptswift+8
Student: Aneesa Fatima
Code
Proposal

Client Library System Performance Monitoring Enhancements

advanced
Open Robotics•2026Varies350h (Large)

The ROS 2 ecosystem has made significant leaps in performance over the last few years, supported by benchmarking tools like buildfarm_perf_tests and ros2-benchmark-container. These tools take care of profiling middleware and client library performance under various configurations. As of now, the recurring monitoring path in continuous integration (CI) is mostly rclcpp-centric, providing good regression visibility for C++ implementations. However, a current limitation of the ecosystem is that it lacks periodic performance monitoring for other heavily used client libraries like rclpy (Python) and rclrs (Rust). This leaves these libraries with weaker regression visibility, making it difficult to measure the performance impact of new topologies involving remote host subscriptions or track the performance of ROS actions and services reliably. This project focuses on vastly extending the suite of tests that run regularly in buildfarm_perf_tests by porting C++ benchmark instrumentation for use with the other client library implementations. This project thus aims to add high-signal, recurring CI coverage across rclcpp, rclpy, and rclrs with minimal CI cost overhead. Furthermore, to enhance the contribution, there will also be a focus on updating the performance test result graphs in CI to use modern observability tools. The final deliverable includes an updated web dashboard (built with Grafana) that tracks key compute metrics such as latency, CPU usage, and memory over time, providing the community with a complete, cross-language performance diagnostic ecosystem.

pythonc/c++ros+5
Student: Ammaar Ahmed
Code
Proposal

A GPU-accelerated Model of the Mouse Primary Visual Cortex

advanced
INCF•2022Varies350h (Large)

PyGeNN is a Python package for simulating spiking neural networks using GPUs. For this project, I will construct and simulate a PyGeNN model of the mouse primary visual cortex (V1) by reproducing the point-neuron V1 model created by Billeh et al. (2020). Taking advantage of GPU-acceleration, the PyGeNN model will be able to simulate V1 neural activity in real time. I will first implement a generalized leaky integrate-and-fire (GLIF) neuron class, which will govern the spiking behavior of neurons during simulation. Next, I will construct the network by connecting V1, lateral geniculate nucleus (LGN), and background (BKG) neurons, using the parameters calculated by Billeh et al. (2020). To validate the model, I will compare the results of PyGeNN simulations to those of BMTK/NEST simulations. Finally, I will construct an application that simulates V1 activity in response to a webcam stream in real time. If time permits, I will enhance this application by implementing a GPU-accelerated implementation of the filternet LGN model, which will increase the maximum frame rate that can be simulated in real time. The results of this project will include: (1) a complete model of mouse V1, (2) validation results and benchmark comparisons to BMTK/NEST simulations, (3) a webcam application showing simulated neural activity in real time, and (4) if time permits, a GPU-accelerated implementation of the filternet model.

pythonjavac+++7
Student: William Snider
Code
Proposal

Online Validation Tools

intermediate
Software Product Data Exchange (SPDX)•2017Varies175h (Medium)

<p>Software Package Data Exchange (SPDX) is “a set of standards for communicating the components, licenses, and copyrights associated with software”. You can find the latest (as well as the previous) standards at:</p> <p><a href="https://spdx.org/specifications" target="_blank">https://spdx.org/specifications</a></p> <p>One idea is to accompany software with special files that hold certain meta information: authorship, copyrights, licenses, etc. These files currently come in two major formats: TAG and RDF. There are parsing tools available for these formats in Python and Go:</p> <p><a href="https://github.com/spdx/tools-python" target="_blank">https://github.com/spdx/tools-python</a></p> <p><a href="https://github.com/spdx/tools-go" target="_blank">https://github.com/spdx/tools-go</a></p> <p>These tools do not support the latest SPDX-2.1 standard (instead, they can handle SPDX-1.2) which makes it logical to add support for the latest standard.</p> <p>However, personally I am not happy with the specification which is why I would rather develop an online validation tool with the <a href="https://github.com/nexB/license-expression" target="_blank">license-expression</a> [pyLE] library which heavily relies on the <a href="https://github.com/bastikr/boolean.py" target="_blank">boolean.py</a> library [BP].</p>

cpythonjava+2
Student: Aleksandr Lisianoi
Code
Proposal

GSoC 2026 - Tianyou Liu - Julia Plugin with Virtual Environment Support

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

Dear Sir, I hope you are doing well. My name is Tianyou Liu, and I am writing to submit my GSoC 2026 proposal for Mogan STEM: “Julia Plugin with Virtual Environment Support.” In the proposal, I describe an implementation plan to enable Julia-powered, reproducible computing directly inside Mogan. The key technical components include: Mogan-side Julia plugin to identify and extract Julia code sections and provide an in-editor execution workflow. A persistent local Julia kernel process to execute code on demand and maintain session state across runs. A lightweight IPC layer between Mogan and the kernel (socket-based, request/response), returning structured execution results for rendering. Output and error capture (stdout/stderr, stack traces, and rich results where applicable) to present execution feedback clearly inside Mogan. Project-aware environment activation by automatically locating the nearest Project.toml (and using Manifest.toml when present) and executing code in the corresponding Julia environment. Integration with Julia’s Pkg workflows to support reproducible dependency management (e.g., activate/instantiate and related environment operations). My resume is enclosed in the attachment. More details are discussed in the proposal enclosed in the attachement. Thank you for your time and consideration. I look forward to the possibility of contributing to Mogan STEM this summer. Best regards, Tianyou Liu Email: liuty2025@mail.sustech.edu.cn GitHub: https://github.com/AXeonV

c++qtscheme
Student: AcceleratorX
Code
Proposal

Enhancing Developer Experience Through Automation and Workflow Optimization

advanced
Open Food Facts•2025Varies350h (Large)

Open Food Facts (OFF) relies on contributions from a global community of developers and volunteers. However, setting up development environments, navigating complex CI/CD pipelines, and contributing to multiple repositories like off-server, robotoff, and smooth-app can be time-consuming and frustrating—especially for newcomers. This project aims to streamline the entire contributor journey by creating a unified, cloud-powered Developer Experience (DevX) platform for OFF.\n \n We will implement pre-configured Google IDX, Gitpod and Codespaces environments, enabling contributors to start coding within minutes. The CI/CD pipelines will be optimized to run only affected modules, significantly cutting build and test times. We'll also create a live, versioned documentation pipeline, integrate AI-powered tools for issue triage and PR review, and develop a metrics dashboard for maintainers to track workflow efficiency.\n \n Deliverables include: \n - Deployment staging environment with Docker swarm or Ansible.\n - Auto-launch Gitpod/ Codespace environments. \n - Optimized CI/CD workflows with modular test execution. \n - Automated documentation site using OpenAPI Spec + MDX + Fumadocs. \n - AI bot integration for issue triage. \n - A real-time DevX dashboard. \n \n This project will empower contributors to go from zero to green PRs faster, making OFF development more accessible, efficient, and scalable.

androidmachine learningmongodb+6
Student: Jagjeevan Kashid
Code

Implementing Coarray Support in LFortran

intermediate
Fortran-lang•2026Varies175h (Medium)

This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.

pythonc/c++llvm+3
Student: Jainam_29
Code
Proposal

Supervisor Domains Priv. ISA Extension Emulation Mentorship Project

Intermediate
•Varies175h (Medium)

Security-sensitive workloads on embedded and server platforms require isolation primitives to support many use cases that require enforcement of confidentiality and integrity for workload against software and hardware adversaries. Providing these protection properties requires architectural support for page-based physical memory isolation managed at the machine level to be able to create isolated supervisor domains which can then host isolated S/H and (V)U, V(S) mode software. A supervisor domain can extend the trusted computing base (TCB) to host isolated VMs and/or applications. The Supervisor domains task group has defined privileged ISA extensions (Smsdid, Smmtt, Smsdia, Smsedbg etc.), to be used by machine mode to isolate physical memory, and other platform resources flexibly across supervisor domains. As specified in the RISC-V Supervisor Domains specification, per-hart controls for a supervisor domain identifier can be used to program a memory tracking table (MTT) structure that will specify if a supervisor domain is allowed to access physical memory regions (at architectural page-size granularities). The MTT will be programmed by an M-mode root-domain security manager (RDSM). The mentee will primarily focus on developing extensions to Qemu to emulate the RISC-V Supervisor Domain (Smmtt) ISA extensions, and build an priv. software prototype for the M-mode RDSM using OpenSBI to demonstrate the functionality of the emulated ISA.

TBA
Proposal

Implement WASI and wasmedge_process host functions on Windows

advanced
CNCF•2022Varies350h (Large)

WebAssembly has become extremely popular among the developer community lately. It offers near native performance in a browser and is meant to not be a hand written language but to be the compilation target of source languages like C, C++, Rust etc. It provides a way to run code written in multiple languages on the web at near-native speed, with client apps running on the web that previously couldn't have done so. It, being a new language , does not enjoy wide support across platforms. The prospect of having a unified interface for web developers has long been elusive. It has the potential to provide the basis on which many apps can be built and deployed for a huge range of devices from IoT devices to fully fledged servers. But to enable developers to use it we need a WASI runtime ecosystem to support them. WasmEdge is one such project that aims to bring WebAssembly to the edge. To provide a unified interface accross multiple platforms, a interface between WasmEdge and the host operating system has to be built. This interface is specific to the platform on which the runtime is deployed and has to be built individually and specifically for each platform bearing in mind the features available. The native API provided by the OS should be used to implement many of the common operations like file manipulation, IO etc. These 'host functions' are crucial for the project to succeed and have been defined in WASI - the Web Assembly System Interface which is a modular collection of standardised APIs Currently, host specific functions have not been implemented in WasmEdge, for the windows platform. These functions are supposed to be implemented using the Win32 API and have to go rigorous testing before being deployed.

gorustkubernetes+3
Student: Abhinandan Udupa
Code
Proposal

Evaluate Gemini on an Open-Source Benchmark: OpenUI Eval

advanced
Google DeepMind•2025Varies350h (Large)

This project evaluates large language models on frontend coding and UI generation tasks by extending and integrating ideas from open-source coding benchmarks such as Multi-SWE-bench and WebDev Arena. The evaluation framework assesses coding and UI generation capabilities across various dimensions, with particular emphasis on multimodal features for frontend development. It leverages the models’ ability to generate, render, and iteratively refine solutions using visual feedback from rendered UIs, and supports multiple frontend frameworks (React, Vue, Angular, Svelte, Next.js) alongside single-file HTML tasks. The solution involves building a modular pipeline with typed configuration, provider adapters (Ollama, vLLM, OpenRouter), and a model manager; implementing multimodal evaluation loops that incorporate screenshots and structured judging; supporting iterative evaluation (allowing models to refine solutions over multiple attempts); expanding the task taxonomy with increasingly complex frontend challenges (calculators, dashboards, interactive apps, framework-based projects); and automating the entire evaluation pipeline with reproducible runs and detailed artifact logging. Deliverables include the enhanced evaluation framework with new benchmark tasks, structured outputs and reports (JSON, screenshots, summaries), automation scripts for reproducible runs, and thorough documentation. The framework provides a transparent and extensible way to compare advanced AI coding capabilities in frontend development without relying on a leaderboard, focusing instead on rigorous, reproducible benchmarking.

pythonjavascripttypescript+2
Student: @anxkhn (Anas Khan)
Code
Proposal

Random Test Generation for RISC-V Vector Extension Mentorship Project

Intermediate
•Varies175h (Medium)

"Following the ratification of RVV specification, the software simulation framework and RTL designs for RVV have been released. Given the complexity of RVV design and the combinations of its configuration, both developers and users need a golden test suite to verify the correctness of the respective RVV implementations and simulations. RIOS lab thus introduces this project and contributes to RISC-V foundation. In this project, you will be designing a RVV test generator to help verify the functionality of either simulator or ASIC design of RISC-V vector processors. This project has two phases. In the first phase, we will write the a constant test suite generator for RVV that automatically produces the same test streams given a fixed RVV configuration. This would help debug and ensure reproducibility needed by developers. While in phase 2, we will extend the test generator to produce random vector test to cover the corner case of the RVV design. RVV Spec: https://github.com/riscv/riscv-v-spec RISC-V CTG: https://github.com/riscv-software-src/riscv-ctg RISCOF: https://github.com/riscv-software-src/riscof RISCOF Documentation: https://riscof.readthedocs.io/en/latest/intro.html Learning Objectives: 1. RVV instruction set architecture 2. How does vector processor work? 3. Formal Verification of RVV 4. Test generation and verification model 5. Design of advanced random test generation framework

TBA
Proposal

Porting AOSP 12 emulator to RISC-V RV64G Mentorship Project

Intermediate
•Varies175h (Medium)

This program pairs one or more mentees with an experienced mentor to deliver an AOSP 12 emulator for 64-bit RISC-V. RISC-V International has setup Android SIG and released RISC-V Android github repo as https://github.com/riscv-android-src. Current RVI Android codebase is based on AOSP 10, while the latest AOSP is 12 now. We hope to catch up with latest AOSP 12 codebase, and as part of our plan, an emulator is required first as test and run environment. Deliverables (bullet list of components and the changes expected): - Add RISC-V target in the emulator. - Porting Ranchu virtual board to support RISC-V machine. - Corresponding unit tests implementation - Regression tests pass Note: upon work should be based on AOSP 12. 3. acceptance criteria Acceptance criteria (bullet list with measurable results defined): - Phase I: Virtual peripherals of emulator can work with RISC-V 64bit cores and pass unit tests. - Phase II: Emulator can boot-up with Linux plus basic rootfs w/o GUI for AOSP 12. - Phase III: Emulator can boot-up with Linux plus rootfs w/ GUI for AOSP 12. Note: due to AOSP 12 rootfs is still in developing, a AOSP 10 rootfs from Android SIG repo can be used instead to help verification, but the kernel version should be matched with AOSP 12.

TBA
Proposal

Commons Numbers Library for Complex Linear Algebra

advanced
Apache Software Foundation•2022Varies350h (Large)

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

pythonjavascriptjava+7
Student: Sumanth Sulur Rajkumar
Code

FinBot CTF: A Pluggable Guardrail Framework & MCP-Based Defense Scenario Pack

intermediate
OWASP Foundation•2026Varies175h (Medium)

FinBot CTF is OWASP's premier learning environment for agentic AI security, yet it currently operates solely as an offensive arena. Practitioners can exploit vulnerabilities but lack the capability to implement, test, and score defenses against the OWASP Agentic Top 10. This project closes the blue-team loop by introducing a production-inspired, hook-based security framework. The solution is a four-part architecture: (A) a pluggable Guardrail & Detection Framework with pre-tool, post-output, and pre-action hooks that emit a standardized security event model; (B) a Defense-Enabled Challenge Pack converting 3-5 existing offensive challenges (A2: Excessive Agency, A3: Memory Poisoning, A8: System Prompt Leakage) into paired red/blue tracks with integrated defensive scoring; (C) an MCP-Style Scenario Module featuring benign and malicious JSON-RPC tool servers, with detectors for output poisoning, prompt injection via payload, and unauthorized endpoint redirects; and (D) comprehensive Documentation & CI including Docker Compose, contributor guides, and a GitHub Actions test suite. This work transforms FinBot into a complete AI security training platform. Leveraging my prior contributions to the codebase, I will deliver a low-risk, high-impact implementation that equips defenders to build, test, and validate guardrails against real-world agentic threats, solidifying FinBot's role as the practical counterpart to the OWASP Agentic Top 10.

pythonjavascriptjava+10
Student: Regis MUKIZA
Code

[PolyPhy] Polyphorm / PolyPhy - PolyPhy infrastructure engineering and practices

advanced
UC OSPO•2023Varies350h (Large)

This proposal aims to enhance the infrastructure of PolyPhy by developing new architecture and maintaining existing codebases. The project will involve refactoring the current codebase, creating interfaces for PolyPhy that enable access to its features through Python/Jupyter code and command line, configuring the codebase according to the team's needs, and improving the performance, security, and documentation of PolyPhy. To achieve these goals, I will refactor existing codebase and enhance the PolyPhy package, create a common API to allow multiple and dynamic changes to the pipeline, implement efficient CI/CD workflows for the PolyPhy repository, including unit and integration tests, and create a public pip package release for PolyPhy. Additionally, I will implement a monitoring and logging system to detect and diagnose issues with the software in production, perform profiling and load testing to improve code quality and performance, and establish security best practices such as code reviews, vulnerability scanning, and penetration testing. The expected result of this project is a robust and user-friendly PolyPhy package that can handle different parts of the pipeline, has an efficient CI/CD workflow, and adheres to security best practices. The package should be Dockerized, and the build process should be automated using Docker tools, which will help in maintaining consistency across multiple platforms. Moreover, there should be a Github page workflow for the PolyPhy website deployment, and an issues template should be created to promote people from opening issues on the repos. Finally, the documentation should be improved, and a release management process should be established that includes versioning, release notes, and changelogs.

pythonc/c++visualization+5
Student: Prashant Jha
Code

Interfacing PODIO to Julia

advanced
CERN-HSF•2022Varies350h (Large)

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

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

Breaking the Thread Barrier: Boosting I/O Performance with io_uring and FS2

advanced
Scala Center•2023Varies350h (Large)

The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.

#scala#scala_lang#jvm+7
Student: Antonio Jimenez
Code
Showing 3265 - 3288 of 3339 Projects
135136137138139
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal