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

Switching to Conscrypt as the default security provider

advanced
Robolectric•2022Varies

Ready to Apply?

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

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

Switching to Conscrypt, simulating the security APIs becomes much more high-fidelity and it achieves the goal of Robolectric to make it similar to an Android environment. Currently, Robolectric uses BouncyCastle as the Java Cryptography Extension (JCE) security provider. Starting in Android P, Android switched to using Google Conscrypt as the security provider. To be more consistent with Android, Robolectric should update the default security provider to Conscrypt. As it is using the BouncyCastle, this means that whenever the JCA APIs are used in a Robolecetric test, BouncyCastle will be used by default. Officially, In Android the default JCE provider is Conscrypt. This is a Java wrapper over BoringSSL. The goal is to have Robolectric switch from BouncyCastle by default to Conscrypt. The Conscrypt module uses BoringSSL, a native library that is a Google fork of OpenSSL and which is used in many Google products like Google Chrome for cryptography and TLS. Conscrypt uses Java code and a native library to provide the Android TLS implementation as well as a large portion of Android cryptographic functionality such as key generators, ciphers, and message digests. Conscrypt is relatively selective and focuses on the most important and widely-used algorithms. Conscrypt also supports the curves in Elliptic Curves crypto operations and it is much faster than BouncyCastle as it is optimized native code. But BoringSSL doesn't have official releases and makes no guarantees around API or ABI stability.

androidjavajvm+1
Student: Umesh Singh
Code
Proposal

Implementing Sloan Ordering Algorithm from Boost Graph Library to pgRouting

advanced
OSGeo (Open Source Geospatial Foundation)•2025Varies350h (Large)

This project aims to integrate the Sloan sparse matrix ordering algorithm from the Boost Graph Library into pgRouting, enhancing its capabilities for graph optimization for both undirected and directed graphs. The Sloan algorithm generates optimal vertex ordering that reduces profile and bandwidth of graphs, significantly improving the efficiency of matrix operations in network analysis applications. While pgRouting includes several matrix manipulation algorithms, it lacks specific matrix ordering algorithms like Sloan ordering that are essential for optimizing sparse matrices in network analysis. Current workarounds require users to export data to external tools, breaking workflow continuity. I plan to develop a new function pgr_sloanOrdering() with complete integration, comprehensive error handling, and support for both directed and undirected graphs. The implementation will leverage the Boost Graph Library's existing algorithm with careful adaptation to pgRouting's architecture. The project deliverables include a fully implemented Sloan ordering algorithm integration, comprehensive documentation and usage examples, an extensive test suite with performance benchmarks, and support for various graph types with configurable parameters. This project will benefit the community by expanding pgRouting's graph analysis capabilities, particularly for applications in transportation networks, utility network management, and scientific computing where matrix ordering significantly impacts computational efficiency.

pythonjavascriptc/c+++4
Student: Bipasha Gayary
Code

Masked Auto-Encoders for End-to-End Particle Reconstruction and Compression for the CMS Experiment

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

Proposal Summary: The project aims to achieve two primary objectives: efficient and precise particle identification and the development of effective lossless data compression techniques for the CMS Experiment at the Large Hadron Collider (LHC). Efficient and Precise Particle Identification: Traditional particle identification methods involve complex algorithms analyzing data from the CMS detector. Recent advancements suggest using convolutional neural networks (CNNs) directly on raw detector images, known as the "end-to-end" approach, for streamlined processing and competitive identification efficiency. The project seeks to explore and enhance vision transformers (ViTs) for particle reconstruction, benchmarking against established CNN models. Development of Effective Lossless Data Compression Techniques: The CMS experiment generates massive amounts of data from particle collisions, posing challenges in processing and storage. Data compression techniques are crucial for extracting relevant information while reducing data volume for efficient processing and analysis. The project aims to develop innovative masked auto-encoders (MAEs) with vision-transformer-based encoders for efficient data compression, enhancing downstream tasks' performance. Overall, the project endeavors to contribute to advancing particle physics research by improving particle identification accuracy and optimizing data handling through innovative data compression techniques.

pythonmachine learningc+++2
Student: Shashank Shekhar Shukla
Code

Introduction to Linux Kernel Development Mentorship Project

Intermediate
•Varies175h (Medium)

APPLICATIONS ARE CLOSED. Please apply again in the Fall! We will post more information when it is available. Linux is the most widely used operating system in the world. The core software component of the Linux operating system is the kernel. Some of its roles include managing hardware interactions, virtualizing system resources, and enforcing security constraints. In effect, the Linux kernel powers almost all of the world's top supercomputers, android phones, and an innumerable variety of other computers. This course will introduce students to the Linux kernel development by focusing on device driver development, particularly character devices and the /proc and/sys interfaces. This will give students hands-on experience working with internal Linux kernel APIs for hardware access, memory management, DMA and interrupts, among other, and provide an overview of some of the core features and components of the kernel, such as scheduling, system calls, the boot process, and hardware description trees. Gaining an understand of the inner workings of the operating system and how to make changes to it will give students an invaluable perspective on how computers work behind the scenes, which will reveal a new layer of understanding to apply to any future software engineering practice. This is a new format of the following courses we created: https://www.uml.edu/catalog/courses/COMP/3085 or https://www.uml.edu/catalog/courses/COMP/5170

TBA
Proposal

Cognitive Ecosystem: Unified Agent Coordination, Observability, and Intelligence for MoFA

advanced
MoFA Org•2026Varies350h (Large)

MoFA agents currently operate as "black boxes" in isolation—they lack shared memory, structured handoff protocols, and cross-agent coordination. When a multi-agent swarm fails, there is no single distributed trace to follow and no system-wide intelligence to explain why. This proposal transforms MoFA from a collection of individual agents into a "Cognitive Ecosystem" by implementing a symbiotic coordination-and-observability layer. Building on the OTLP+Prometheus pipeline with a 336x performance gain and the core coordination traits I designed (PR #997), this project delivers: (1) An AgentHub Coordination layer featuring InMemoryVectorStore for semantic memory and ChannelHandoffProtocol for reliable task delegation; (2) A zero-copy EventRecord Bridge using tokio::broadcast to fan out state mutations; (3) An Observatory Intelligence Engine featuring a petgraph-powered Knowledge Graph for live topology mapping and a Z-Score Statistical Anomaly Detector for identifying rogue agent behavior (token burn, latency spikes). The result is a production-grade "Nervous System" for MoFA where every agent interaction is first-class, observable, and governed. Key metrics include: Zero-drop event propagation at 4000 EPS, <50ms graph query latency, 80%+ unit test coverage, and a full W3C TraceContext implementation for cross-agent waterfall visualization.

pythonrust
Student: Ashum9
Code
Proposal

GSoC 2024 Proposal - OSASIS TOSCA Language Server

intermediate
Eclipse Foundation•2024$6k–$13.2k350h (Large)

The proposal aims to enhance Eclipse Winery, a web-based environment for modeling OASIS TOSCA topologies, by implementing basic security measures. Currently, Winery focuses on providing a graphical editing environment for modeling application topologies. However, the proposal suggests adding a Language Server Protocol (LSP) provider for OASIS TOSCA YAML files. This would allow Winery to support the latest version of the OASIS TOSCA standard and handle dynamic type additions. The expected outcomes of the project include: 1-Developing an LSP server that supports the latest OASIS TOSCA 2.0 standard. 2-Ensuring that the LSP server is aware of newly introduced types and makes them available in the service template. 3-Enabling the LSP server to handle multiple files. 4-Demonstrating the functionality of the LSP server using compatible IDEs such as Eclipse Theia, Visual Studio Code, or Eclipse IDE. 5-Writing clean and maintainable code, with a preference for using modern Java (version 21 or later). The proposal indicates that the project's size is estimated at 350 hours and rates its difficulty as medium. Overall, the proposal aims to improve the security and functionality of Eclipse Winery by implementing an LSP server for OASIS TOSCA YAML files, thereby providing a more robust and comprehensive modeling environment.

c/c++javageospatial+15
Student: Omar Awad
Code
Proposal

Implementing Multi-page Folio Support in OpenAFS Linux Kernel Module

advanced
OpenAFS•2025Varies350h (Large)

This project enhances the OpenAFS Linux kernel module with multi-page folio support, addressing a key performance limitation in the current implementation. OpenAFS currently interacts with the Linux kernel's memory management system through single-page operations, despite recent kernel versions offering folio APIs capable of managing multiple contiguous pages as a single unit. I will implement comprehensive multi-page folio support in OpenAFS by modifying key components of the cache manager, particularly focusing on the VFS interface layer where the largest performance benefits can be realized. The implementation will optimize read and write paths to efficiently handle larger memory regions while maintaining backward compatibility with older kernel versions through autoconf detection and conditional compilation. By the end of the project, I will deliver: (1) A complete implementation of multi-page folio support that improves performance, especially for sequential read operations common in application deployment; (2) A comprehensive testing framework verifying functionality across multiple kernel versions; (3) Detailed performance benchmarks demonstrating throughput and resource utilization improvements; and (4) Thorough documentation of implementation details to facilitate future maintenance. All code will be submitted as incremental, well-structured patches adhering to OpenAFS coding standards.

cpythongit+4
Student: Sushil Pandey
Code

Late Antiquity Model Projection - LAMP

advanced
HumanAI•2026$6k–$13.2k350h (Large)

This GSoC 2026 project proposes an advanced, open-source computational pipeline for the Late Antiquity Modelling Project (LAMP) to reconstruct historical movement and visual connectivity, moving beyond deterministic archaeological GIS with a data-driven, modular approach. The core objective replaces standard Least-Cost Path analysis with a Probabilistic Path Ensemble. Utilizing Maximum Entropy Inverse Reinforcement Learning (MaxEnt IRL), the pipeline autonomously learns historical cost weights by balancing terrain slope against surface friction derived from K-Means clustered SAR and Multispectral imagery. Additionally, the routing engine leverages spectral anomaly detection and structure tensors to uncover subtle pathways hidden in the landscape. The project's second pillar introduces 3D Viewshed Analysis. By processing high-resolution terrain geometry (.obj files) to calculate precise 3D lines of sight, the toolset enables researchers to evaluate the visual prominence and strategic interconnectivity of ancient settlements and outposts. Built over 12 weeks using robust Python geospatial libraries (Rasterio, GeoPandas, SciPy), the final deliverable is a scalable, mathematically rigorous toolkit. It will serve immediate LAMP needs at sites like El Bagawat while remaining seamlessly transferable to any archaeological context requiring advanced spatial modeling.

pythonmachine learningc+++2
Student: Manan Wadhwa
Code
Proposal

Expanding binary compatibility mode

advanced
Unikraft•2023Varies350h (Large)

One of the weak points of most unikernel projects has always been application support, often requiring that applications be ported to the target unikernel OS. In this area, Unikraft has made significant progress by prioritizing POSIX compatibility. Through its binary compatibility mode, Unikraft allows unmodified ELFs to be executed, with resulting syscalls wrapped and redirected to the Unikraft core via the app-elfloader. Currently, Unikraft supports loading both statically and dynamically linked ELFs in binary compatibility mode. However, Unikraft has not been able to fully support all behaviors of glibc and user applications, which causes certain programs to fail in initializing or crash. Additionally, running applications in binary compatibility mode incurs performance loss compared to ported programs, due to the TLS switching and system interrupts caused by binary syscalls. To address the issues mentioned above, this project focuses on expanding Unikraft's binary compatibility mode by: * Using vDSO (virtual dynamic shared object) and vsyscall (virtual system call) to bypass binary syscalls. * Expanding supported syscalls to provide compatibility for a wider range of applications. * Adding AArch64 architecture support for app-elfloader and syscall-shim layer. * Implementing a faster way to port new applications by externally compiling. * Establishing a CI/CD system to ensure that new commits do not break libc compatibility.

cpythonxen+3
Student: Tianyi Liu
Code
Proposal

Simulating bob_robotics models using Gazebo

intermediate
INCF•2019Varies175h (Medium)

<p>Brains on Board (<a href="http://brainsonboard.co.uk" target="_blank">http://brainsonboard.co.uk</a>) is an inter-university project with the aim of developing an autonomous flying robot with the learning abilities of a honeybee, with all computation performed on board. Part of the project involves developing a lightweight C++ library for running neural simulations in real time on small robots (<a href="https://github.com/BrainsOnBoard/bob_robotics" target="_blank">https://github.com/BrainsOnBoard/bob_robotics</a>). The BoB robotics framework currently lacks the following:</p> <ul> <li>A physics-based simulation engine</li> <li>Models of the sensors being used</li> </ul> <p>This project aims to integrate BoB robotics with a more sophisticated 3D simulation package i.e. Gazebo. The main contributions of this project shall be:</p> <ul> <li>Prepare Gazebo world environments for real-world 3D models that are currently available with bob_robotics. </li> <li>Modelling the sensors (specifically those that mimic the vision of insects) and robots used by the BoB robotics team into Gazebo.</li> <li>Integrating Gazebo with BoB robotics so that the simulated robots can be controlled using BoB robotics models, e.g. test out a navigation model on a good simulated model of a drone.</li> </ul>

pythonjavac+++7
Student: Shinjan Mitra
Code
Proposal

A stream log processing framework for WasmEdge

Intermediate
•Varies175h (Medium)

In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.

TBA
Proposal

AnomalibVLM: Enhancing Anomaly Detection with Vision Language Models.

intermediate
OpenVINO Toolkit•2024Varies175h (Medium)

Problem: Traditional anomaly detection systems often struggle with limited data scenarios and can lack the ability to explain their detections. Addressing these challenges is crucial for advancing the field and expanding its application range. Solution: This project proposes the integration of Vision Language Models (VLMs) into the anomalib framework using OpenAI's API. The goal is to enhance anomaly detection capabilities through few-shot and zero-shot learning techniques. This integration involves creating a new model class, 'LVM_openAI', as a subclass of 'AnomalyModule', and incorporating unique parameters like API_key and custom prompts. The model will leverage OpenAI’s API for processing and interpreting data, and will handle error catching, response parsing, and anomaly detection. Methodology: The project will start with a deep dive into Anomalib and OpenAI’s ChatGPT API, followed by a design and prototyping phase. The development will be in phases, with each phase focusing on different aspects of the integration, including testing with various datasets (e.g., MVTec AD and LOCO) and comparing against other models. Additionally, a comprehensive documentation, including a detailed notebook for setting up and using the model, will be created. Deliverables: An integrated VLM-based anomaly detection system within anomalib. Complete documentation and a set of experiments demonstrating the efficacy of the approach. An optional user interface for enhanced model interaction.

pythonc++x86+1
Student: Bepitic - Paco Amoros Cubells
Code
Proposal

Improving Site Performance and Implementing Subject Tags

advanced
Internet Archive•2023Varies350h (Large)

The objective of this proposal is to enhance the user experiences for readers of Open Library through a two-prong approach. The first prong, Improving Site Performance, addresses the poor site performance that negatively affects our patrons’ experience. This prong takes a metric-based approach to identify the key bottlenecks of performance using various performance measurement tools. This metric-based approach allows us to identify the areas for performance optimisation and quantify the effects of our changes. The second prong, Implementing Subject Tags, seeks to offer a more resourceful alternative to the Subject tags that are currently implemented for books in Open Library. The current Subject tags, which are implemented as a list of strings, are limited in extensibility and scalability, and are not an efficient tool in categorising and providing information about books. Subject Tags will be implemented as first-class objects, allowing for metadata to be included within tags. The metadata will provide relationships and hierarchy between subjects, internationalisation (i18n) information, additional description about tags and many other extensible information fields. Upon the success of this implementation, its utility will catalyse improvement within numerous avenues in the Open Library system which includes the search engine, Subject page interface, content advisory and many more. These two prongs work together to improve the overall patron experience, making the site more enjoyable to use and enriching the information about books.

pythonjavascriptpthon+6
Student: Jayden Teoh Jing Xiang
Code

Newlib Optimization Mentorship Project

Intermediate
•Varies175h (Medium)

"Newlib is a popular C library which is used in embedded systems. It implements important functions used across many applications. It contains e.g. functions that operate on strings or math functions (programs use those when starting with #include <string.h> or #include <math.h>""). Some functions are written in C, while others are written in assembly. There may be speed and code size optimized versions of the functions. A RISC-V specific port for libc has been contributed to newlib in 2017, but has not seen significant updates since. The RISC-V port is not yet as exhaustive as for other architectures. In addition, many new extensions have been ratified since, which can improve performance or reduce code size further, e.g. bit-manipulation (B), Integer Conditional Operations (Zicond), Code Size Reduction (Zc*), with more to come (P, Zilsd/Zclsd). The goal of this project is to optimize newlib for RISC-V. Optimization will be measured in reduction of static code size, or reduction of clock cycles spent in the function. As most instructions are fairly simple, instructions retired might be used as a proxy of cycles. The benchmarking done in this project should compare the performance of the library built for RISC-V, with the library built for other architectures (e.g. ARMv…), and the assembly optimized functions should be compared with generic C libraries compiled for RISC-V with the various extensions enabled.

TBA
Proposal

Hybrid Quantum-Classical Representation Learning for Dark Matter Substructure Classification

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

This proposal presents a plan to develop hybrid quantum-classical models for classifying dark matter substructure from strong gravitational lensing images, as part of the ML4SCI DeepLense project. The classification task involves three classes: no substructure, CDM subhalo substructure, and vortex substructure from axion/fuzzy dark matter. I propose two complementary approaches: Projected Quantum Kernels (PQK), which encode CNN-extracted image features into quantum states and ompute kernel matrices for SVM classification, and Quantum Convolutional Neural Networks (QCNN), which use parameterized quantum circuits as trainable convolutional filters in a hybrid pipeline. Both methods will be benchmarked against classical baselines on the DeepLense Model I/II/III datasets and evaluated under realistic NISQ noise conditions using depolarizing and devicecalibrated noise models, with error mitigation techniques such as ZNE and PEC. Beyond the standard implementations, I also propose using a GPT-2-based autoregressive Transformer to automatically generate task-optimized quantum circuits for both PQK feature maps and QCNN layers, replacing hand-designed circuit templates. Additional experiments include data-efficiency analysis on small training subsets, hybrid kernel fusion combining classical RBF with PQK, and transfer learning evaluation across different dark matter model datasets.

pythonmachine learningc+++2
Student: Jen-Yu Chang
Code

Latent Neural Signatures in Clinical vs. Neurotypical Dyads: A CEBRA Pipeline

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

This project aims to develop a cutting-edge computational pipeline—"Latent Neural Signatures in Clinical vs. Neurotypical Dyads: A CEBRA Pipeline"—to decode and interpret complex neural dynamics during social interactions. By leveraging the CEBRA (Contrastive Embedding for Behavioral and Neural Analysis) framework, the pipeline will process and analyze time-locked 64-channel EEG data from interacting dyads (e.g., speaker-listener pairs). The goal is to generate robust, low-dimensional latent embeddings that capture key features such as neural synchrony, connectivity, and manifold geometry, ultimately distinguishing between clinical populations (e.g., individuals with Autism Spectrum Disorder) and neurotypical participants. To achieve this, the project will integrate rigorous EEG preprocessing (artifact removal, filtering, epoching, and synchronization) with state-of-the-art contrastive learning methods. The pipeline will be built in a modular fashion, allowing for reproducible, open-source research and facilitating cross-disciplinary collaboration between machine learning experts and neuroscientists. Key deliverables include a fully functional end-to-end pipeline, comprehensive technical documentation and user guides, and detailed analysis reports with visualizations and quantitative metrics. This approach promises not only to enhance our understanding of the neural substrates underlying social communication but also to provide a practical tool for clinical diagnostics and personalized intervention strategies.

pythonmachine learningc+++2
Student: jeffreyhuang1009
Code

Python Interface to HDF5 Asynchronous I/O

advanced
Center for Research in Open Source Software (CROSS)•2022Varies350h (Large)

The problem I am solving: The existing HDF5 asynchronous I/O feature supports the C/C++ interface. This project involves the development and performance evaluation of a Python interface that would allow more Python-based scientific codes to use and benefit from the asynchronous I/O. The h5py package provides both a high- and low-level interface to the HDF5 library from Python. The low-level interface is intended to be a complete wrapping of the HDF5 API. The h5py package currently only supports synchronous I/O. And this project I am going to add the Asynchronous I/O. The plan to solve it: Milestone 1: create a new Python API. Milestone 2: convert existing c tests to python tests. Milestone 3: test my implementation with the tests. Milestone 4: evaluate the performance with a scientific python application. When all tests pass we will have a usable Python interface for the asynchronous I/O. An example: the H5Fcreate_async function: First, prepare the H5Fcreate_async.h file, H5Fcreate_async.c file, and we create the cyH5Fcreate_async.pyx file. Second, use the command to Parse pyx source code into c code. Next, use some commands to compile c files into object files (*.o files) Next, use some commands to link multiple object files into dynamic link library files (*.so files) In this way, the file of H5Fcreate_async.so is obtained, and then the library can be imported in the Python application.

pythonc/c++verilog+2
Student: Xuan
Code

Code Coverage and Memory Tracking Improvements for MetaCall Core

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

MetaCall Core is a polyglot runtime written in C/C++ that enables seamless cross-language function calls. Like any large native codebase, it is susceptible to memory leaks and unsafe memory access patterns that are difficult to detect manually and invisible in standard CI. This project improves memory tracking and code coverage reporting across platforms through six deliverables: (1) a Valgrind memcheck CI pipeline integrated into GitHub Actions — already implemented and merged pre-GSoC; (2) systematic fixes to the ~5,579 memory leaks currently detected by CI, reduced from ~99,578 through pre-GSoC contributions (PRs #706, #723, #726); (3) an improved reflect_memory_tracker.h that records file, line, and call-site information for every allocation instead of just counting them; (4) a custom lightweight instrumentation layer using LD_PRELOAD or weak symbol overriding for environments where Valgrind is unavailable; (5) enhanced CI error visibility that surfaces sanitizer-style output for failing tests instead of silent segfaults; and (6) documentation covering the new tracker API, Valgrind output interpretation, and per-loader suppression file strategy. The end result is a MetaCall codebase where memory issues are caught automatically in CI, located precisely when they occur, and actionable for any contributor — not just those with Valgrind expertise.

pythonjavascriptc/c+++6
Student: Nihal_Rodge_
Code
Proposal

Extensions to the Scenic Driving Domain

intermediate
UC OSPO•2026Varies175h (Medium)

Scenic is a probabilistic programming language for generating and verifying environments of autonomous cyber-physical systems. Its driving domain- the primary interface for autonomous vehicle (AV) testing- is a Python library that parses OpenDRIVE road-network files and exposes lanes, roads, intersections, traffic signals, and agents as first-class Scenic objects. While the driving domain is powerful, it has several concrete limitations that hinder real-world usage: assertion failures and geometry artifacts on certain OpenDRIVE maps; a coarse-grained centerline-following model that accumulates error on curved roads; incomplete extraction of semantic road metadata; and absent lane-signal linkage that makes it impossible to write autopilot behaviors that respect traffic laws. This proposal addresses all of these gaps across two major tracks and five subtasks, matching the project outline provided by the mentors: - Track 1 (~4 weeks): Robustness - fix known bugs, expand the test suite. - Track 2 (~5 weeks): Features - Frenet-frame geometry, lane-following distance, semantic tags, signal-lane linkage, and modular scenario components. Each subtask explained in the proposal will produce independently reviewable pull requests, letting mentors integrate work incrementally. The result is a driving domain that is meaningfully more robust, more expressive, and better validated than today.

pythonc/c++visualization+5
Student: Ashwin Prabou
Code
Proposal

Controller Area Network (CAN) Stack Improvement: BeagleBone Black D-CAN Driver Implementation

intermediate
RTEMS Project•2026Varies175h (Medium)

This project implements a D-CAN driver for the AM335x controller on the BeagleBone Black and integrates it into the RTEMS CAN stack, addressing the current lack of CAN support for this widely used embedded platform. This enables RTEMS applications to access CAN communication through standard interfaces such as /dev/canX. The main challenge lies in bridging the mismatch between the mailbox-based D-CAN hardware architecture and the queue-based abstraction used in RTEMS. To address this, the driver will introduce a mapping layer that emulates FIFO-based reception using hardware message objects and implements a software-managed, priority-aware transmission mechanism. Synchronization will be carefully handled through IFx register access and interrupt management to ensure correctness and real-time behavior. The implementation will follow an incremental approach, starting with a minimal working driver (initialization, polling-based TX, FIFO RX), and then extending to interrupt-driven operation, improved mailbox utilization, and priority-aware scheduling. Validation will be performed on real hardware using loopback and cross-platform communication tests (RTEMS ↔ Linux). Deliverables include a fully functional and maintainable D-CAN driver integrated into RTEMS, along with documentation, test demonstrations, and validation results. This work will also serve as a reference for future CAN driver development within the RTEMS ecosystem.

cpythonembedded systems+5
Student: riverquiet
Code

Flexible Graph Construction for Neural Weather Prediction

intermediate
MLLAM•2026Varies175h (Medium)

Neural weather prediction models like neural-lam rely on graph neural networks, but the current graph construction pipeline is locked to rectangular grids — blocking support for irregular data sources like weather stations, satellite swaths, and icosahedral model grids (ICON, MPAS). This project replaces the hardcoded pipeline with a flexible, topology-agnostic architecture spanning two repositories (weather-model-graphs and neural-lam). The core work delivers three things: (1) a two-step mesh architecture that decouples node placement from connectivity, enabling any layout (triangular, prebuilt, density-adaptive) to combine with any connectivity mode; (2) a bridge layer that eliminates 600+ lines of duplicated code by making neural-lam call weather-model-graphs directly, validated through a shared schema contract; and (3) migration to PyTorch Geometric's HeteroData for type-safe, self-documenting graph representation. As stretch goals, the project introduces a graph quality metrics framework for comparing mesh topologies without training, density-adaptive meshing driven by data or prediction error, and spherical coordinate support to fix systematic distortion at high latitudes. I have already contributed the foundational PRs (#81, #91, #92, #123, #258) and authored the two strategic issues (#384, #385) that define this project's architecture.

pythonnumpypytorch+2
Student: Prajwal_07
Code
Proposal

Add anova Classdef Object to the GNU Octave Statistics Package

advanced
GNU Octave•2026Varies350h (Large)

This project implements an anova classdef for the GNU Octave statistics package, providing a unified object-oriented interface for one-way, two-way, and N-way analysis of variance. The anova class delegates core computation to the existing anova1, anova2, and anovan functions, preserving their tested logic while exposing a clean, MATLAB-compatible OOP API with properties (Coefficients, anova table, fitted values, residuals, diagnostics) and methods (summary, multcompare, plotDiagnostics, predict, getEffectSizes). The class stores model state, enabling interactive post-hoc workflows without refitting. Beyond the classdef, the project delivers targeted performance improvements to the underlying functions: vectorizing loop-heavy group statistics in anova1 with accumarray, vectorizing anova2 SSE computation, reducing memory in anovan interaction column construction, and adding NaN handling to anova2. Deliverables: (1) anova classdef with constructor, properties, and core methods, (2) summary and display methods with formatted ANOVA table output, (3) multcompare method for post-hoc pairwise comparisons, (4) plotDiagnostics method for residual and leverage plots, (5) performance optimizations to anova1, anova2, anovan internals, (6) NaN handling for anova2, (7) comprehensive BISTs and Texinfo documentation, (8) benchmark suite. All computation reuses existing functions with no architectural rewrites.

c++hg
Student: beingamanforever
Code
Proposal

Automated Vulnerable Environment Provisioning for Metasploit

intermediate
Metasploit•2026Varies175h (Medium)

Many Metasploit modules include documentation describing how to manually build vulnerable test environments. However, these setup steps are performed outside the framework and often vary between users, making exploit verification slower and less consistent. This project proposes a new Metasploit command, build_vuln, that automates the provisioning of vulnerable environments directly from within msfconsole. The command will resolve a module’s associated environment definition and launch the environment using OCI compliant container configurations. The system will support both Docker and Podman runtimes, including rootless execution, through a runtime abstraction layer that avoids tight coupling to a specific container engine. A health management component will ensure environments are ready before exploitation, while an in memory registry will track environments created during the active session and allow users to list, manage, and tear them down. The project will also introduce standardized reusable environment definitions that can be referenced by multiple modules. Selected modules that currently rely on manual Docker instructions will be refactored to use the new mechanism, and a CI integration prototype will demonstrate how these definitions can be reused for automated module verification. The final deliverables include the build_vuln command implementation, container runtime integration, standardized environment definitions, reference module refactoring, CI integration prototype, and comprehensive developer and user documentation.

crubyasm+3
Student: Nayera Ahmed Shafik Mostafa
Code
Proposal

Fuzzing Graphics Shaders

intermediate
Android Graphics Tools Team•2020Varies175h (Medium)

<p><a href="https://github.com/KhronosGroup/SPIRV-Tools" target="_blank">SPIRV-Tools</a> is a collection of tools to work on <em>SPIR-V</em> modules. One of these tools is <em>spirv-fuzz</em>. It applies <em>semantics-preserving transformations</em> to a <em>SPIR-V</em> module, that we call the <em>reference</em> module, to obtain a modified <em>variant</em> module. Theoretically, a <em>semantics-preserving transformation</em> should not change the behaviour of the code. In this way, the <em>reference</em> and <em>variant</em> modules can be run, and the outputs compared. The output is usually an image. If the images differ, this probably indicates a shader compiler bug. This is a specialised form of <em>fuzzing</em> that uses a technique called <em>metamorphic testing</em>.</p> <p>This project involved using the metamorphic testing approach to extend <em>spirv-fuzz</em> by adding new transformations to cover instructions and patterns of <em>SPIR-V</em> that were not previously covered by existing <em>spirv-fuzz</em> transformations. Also, the project used tools such as <a href="https://github.com/ChrisLidbury/CLSmith" target="_blank">CLSmith</a> and <a href="https://github.com/google/clspv" target="_blank">clspv</a> to improve <em>spirv-fuzz</em>.</p>

c/c++javaopengl+5
Student: André Perez Maselco
Code
Proposal
Showing 3769 - 3792 of 3883 Projects
156157158159160
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal