Explore Projects

<p>The Audiovisual data present with Red Hen is not shareable. The visual data clearly shows the speakers involved, and a person can be recognized with the recorded audio. These datasets cannot be shared easily to protect the privacy of people. Thus, Red Hen needs an anonymization engine for its audiovisual data. Using audio processing techniques, classical computer vision algorithms and recent deep learning algorithms, we propose an anonymization engine. The engine will have a simple web-app interface, where users can choose the type of anonymization desired, or simply choose to randomly anonymize.</p>

<p>On Windows, using the Clang toolchain still depends on Visual Studio. This proposal is to fix these two dependencies: a. BaseTools contains C programs that need to be compiled and executed as part of the build process. While we have gotten Clang to compile UEFI modules, we have not gotten it to compile windows .exe files yet. b. BaseTools currently depends on the nmake.exe program included with Visual Studio, but it also supports GNU make for UNIX systems. A method of building and distributing a Windows version of GNU make needs to be made and BaseTools needs to be adjusted to use it.</p>

Hyperledger Solang is a Solidity compiler written in Rust. It currently targets Substrate contracts pallet (Polkadot) and Solana smart contract runtimes. After successful compilation, users need to upload the compiled contract artifacts to a blockchain node, so it can be interacted with. At the time of writing, this needs to be done manually via third-party web front-ends. Which results in an inefficient and tiring process during iterative contract development. The goal of this mentorship is to implement a Command Line Interface (CLI) for Solang that can be used for node interactions instead. This includes uploading and deploying contracts on-chain as well as submitting transactions to contracts.

Users need to communicate between the cloud and the edge. For example, the cloud calls the rest interface of the edge service. In this case, the routing management function of KubeEdge can be used. Currently, routing management function of KubeEdge has some problems in the case of multiple CloudCore copies. The main problem is that when there are multiple copies of CloudCore, whether the cloud sends messages to the edge or reports the message to the cloud, it is not known which CloudCore is sent to it for processing, and there is confusion in message management in the cloud. In this project, we hope router manager can be optimized to support multi-CloudCore scenario. Expected Outcome: Support using router manager in multi-CloudCore scenario.

<p>Currently Thunderbird uses mbox as primary storage format for mails (locally). All the mails in a folder are stored in the same file with the same name as the folder and no extension. The messages are separated from each other by a "From - " line. The maildir format is also supported, but there is no converter for it yet. The goal is to implement a component to migrate a store from the mbox format to maildir format. In order to achieve the goal a new store should be created and all the messages from all the folders of the old store should be moved to respective folders of the new store in maildir format. The folder hierarchy of the old store needs to be maintained in the new store. The message copying should be carried out in a worker using OS.File to prevent other tasks from getting locked up for long.</p>

Eclipse Vert.x offers a message-driven programming model based on an event bus that allows applications to scale to multiple processes or nodes without requiring code changes or knowledge during development. The event bus can be extended to non-native Vert.x applications, including other platforms such as nodejs, python, etc. Currently, the event bus only supports a vert.x specific custom wire format for messages. This project proposes to add JSON-RPC as another message format for using the event bus. This will make the bridge more accessible to users and allow them to use existing JSON-RPC libraries to communicate with the event bus.

Backward bounded model checking is a technique for program analysis that aims to solve the error location reachability problem by searching for execution paths from an error location to the initial location and determining their feasibility, whereas regular forward techniques search for paths from the initial location to an error location. The main aim of this project will be to formulate the backward bounded model checking algorithm within the framework of CPA and develop an implementation in CPAchecker. This will also require figuring out which components already provide support for backward analysis in CPAchecker and developing support where it does not already exist. Once backward analysis is supported and the algorithm is implemented, it can be tested and benchmarked on a set of programs to evaluate its performance.

ShenYu is a widely used program for limiting, fusing, forwarding, routing, monitoring, and so on. Since ShenYu clusters are able to support a large volume of internet business, it is crucial to decouple the systems and data streams. The Kafka plugins as a high-throughput distributed messaging system will enable ShenYu to have excellent horizontal scalability, scaling to millions of messages per second. It enables the data stream to communicate with less than 10 ms latency, almost real-time message transmission. In this feature, the logging-Kafka plugin will be able to store ShenYu’s logs and take the ShenYu gateway log information, write it to Kafka and display it. The module could be activated as a “Shenyu-plugin”.

This project aims to fix camera and gimbals related issues in ArduPilot, upgrading currently supported messages and adding support for new mavlink messages. Some new and exciting features are also introduced, those are: 1. Pointing gimbal at circle-centre, 2. Gimbal Following another vehicle, 3. Time based triggering of image capture, 4. Start/Stop Video recording when arm/disarm, 5. Camera logging with mount specific messages, 6. GIMBAL_MANAGER_SET_ATTITUDE support, 7. Transferring support of mount poi (point of interest) from lua to c++, 8. Support for specifying which gimbal each camera is associated with, 9. Fixing other bugs in gimbals and cameras (specifically SiYi Zr10)

<p>Multithreaded programming is becoming a mainstream programming practice, while multithreaded programming is difficult and error prone. jpf-trace-server, an extension of Java PathFinder (JPF), can store and analyze traces. The error traces caused by deadlock can also be viewed in a new shell panel from jpf-shell.</p> <p>In this project, we will develop jpf-trace-server to trace the execution of the threads and to provide feedback to the programmer to help them fix the bugs. Inspired by previous work on visualization in JPF, we would like to show the thread interleavings as traces in a new panel of jpf-shell. We would like to show the source code in the panel along with the transition information. The users should be able to walk through each transition of a selected error trace and the corresponding source code where it is executed.</p>

The Problems I am applying to solve are: 1. Building a Tool for Collecting Crowdsourced Ideas on Interactive maps, this is supposed to help people from the community suggest ideas to be built or improved upon by the community 2. Building a dashboard for Equity and City Infrastructure, this is supposed to help the city understand how their investments are impacting the community and help understand how to better equitably invest in infrastructure I plan to build a very accessible, customizable web app with with an interactive map, geolocation capabilities, that allows users to pick locations and suggest ideas to be built or improved on by the city. The app will be serverless and simple to use for the everyday person. The users of this app should also be able to see other ideas that have been suggested and contribute their thoughts on each idea in some way and to help the city understand how these investments are impacting the society and how to more equitably and favorably distribute funds

EchoGem introduces a novel batching engine designed to answer multiple questions about the same source parallelly to reduce response times heavily. It does so by building a modular smart batching engine for Gemini that teaches the model to think in context-aware batches. What sets EchoGem apart is its focus on modularity and testing—each component is designed to be independently swappable and improvable allowing for open testing and matching different strategies for different parts of the engine. Instead of a naive sliding window or top-k search approach, EchoGem uses semantic clustering of both chunks and questions to form intelligent batch groups. It is also committed to measurable, reproducible gains. Every design decision—whether it's a new chunking strategy or a different context ranking model—can be rigorously backtested using a structured evaluation suite.

The CircuitVerse mobile app faces performance bottlenecks (UI jank, slow rendering), inconsistent UX (broken project cards, poor navigation), and missing features (blog integration, interactive book errors). These issues degrade user experience, especially on low-end devices. Solution: 1. Performance Optimization: >Upgrade Flutter, profile with DevTools, and optimize widgets (RepaintBoundary, const constructors). >Reduce rebuilds and repaints for smoother animations. 2. UX Overhaul: >Revamp project cards with default images, share functionality, and Material 3 alignment. >Fix sidebar navigation and add micro interactions (ripple effects, staggered animations). 3. Feature Integration: >Fix the interactive book’s rendering errors with error boundaries. >Integrate blog/Editor’s Pick sections for seamless web-app parity.

Currently KubeArmor depends on kernel headers to use various kernel structures. This creates difficulty in having portability. Linux Kernel versions with BTF (BPF Type Format) information available allows us to write portable BPF CO-RE (or Compile Once - Run Everywhere) applications that can run on multiple kernel versions and configurations without any modification or runtime compilation on the target machine. But there is a restriction that CO-RE requires to have the BTF information of the target kernel, which is provided by the kernel itself when it's compiled with CONFIG_DEBUG_INFO_BTF=y. This option was introduced in Linux 5.2. For kernels < 5.2 we can use BTFGen to ship BTF information with KubeArmor code or use pahole to generate BTF information from the vmlinux image (with DWARF information) at runtime. The project aims to make KubeArmor truly portable across all kernel versions by reducing host environment dependencies.

This project aims to build a reliable OpenSCAD to JavaScript compiler using ManifoldCAD, making it possible to run existing OpenSCAD code in a modern JavaScript environment. The main challenge is that OpenSCAD works in its own ecosystem, while ManifoldCAD cannot directly execute OpenSCAD programs. Current tools are limited and often don’t handle modern features or correct semantics. To solve this, I will develop a proper compiler that accurately models OpenSCAD behavior instead of relying on JavaScript shortcuts. Building on my existing prototype, I will design a structured pipeline with parsing, semantic analysis, and an intermediate representation (IR) to ensure correctness. Key areas include handling modules vs functions, children(), special variables, and improving debugging through source mapping. The final result will be a robust, production-ready compiler integrated into the Manifold ecosystem, enabling developers to reuse OpenSCAD libraries with confidence.

<p>D’s betterC mode is an important tool to be able to use D on bare-metal and embedded platforms. By disabling, for example the class support, the compiles does not need to as many runtime functions and types to be implemented for the code to compile and link. This makes the life of a bare-metal developer much easier.</p> <p>But there is a catch! A lot of the language features runtime hooks, which in turn requires the TypeInfo class to be able to function. One way of solving both of these problems is by moving runtime hooks to use templates instead. This solves the betterC by removing the dependency of classes (the TypeInfo class), and it solves the safety issue because now the compiler will have all the information about the hook and it can verify it itself and not just trust that the runtime developer remembered to mark the hook correctly.</p> <p>This proposal will work on translating all the array hooks from using the TypeInfo class to templates.</p>

LitmusChaos is an open-source chaos engineering platform for Kubernetes, enabling users to test and improve the resilience of their cloud-native applications. The project focuses on improving litmusctl by enhancing its interactive mode with promptui, and refactoring code to Go interfaces for better unit testing and code quality. Additionally, it aims to replace kubectl with client-go for more efficient Kubernetes operations, resulting in a more user-friendly and reliable command-line tool for chaos engineering and workload management. - Expected outcome: The expected outcome of the project includes an improved litmusctl tool with a user-friendly promptui-based interactive mode, enhanced code quality through Go interfaces, and a robust test suite. The migration to client-go for Kubernetes operations will ensure better performance and reduced external dependencies, providing users with a reliable and efficient command-line utility for chaos engineering and Kubernetes management tasks.

The DeepChem project aims to create high-quality, open-source tools to democratize the use of deep learning in drug discovery, materials science, quantum chemistry, and biology. Among its suite of various machine learning models, it has a wide range of graphs-based neural network model implementations aimed to solve the applications such as predicting the solubility of small drug-like molecules, binding affinity for small molecule to protein targets, analyzing protein structures, and extracting useful descriptors. This project seeks to bring a new tool to the DeepChem suite for solving message passing problems based on the recent advancements in GCNs research. This project aims to implement a Directed – Message Passing Neural Network (D-MPNN) model, a graph convolution network (GCN) built upon the existing Message Passing Neural Network (MPNN) model based on the base implementation in Chemprop.

Original project proposal: https://projects.freifunk.net/#/projects?project=openwrt_ppa_part_2&lang=en Currently, compiling OpenWRT packages for a device router requires dealing with the non-standard build system SDK. It would be very useful if this could be abstracted away by a generic build system. This project proposes integration with OpenSUSE's OpenBuildService, which also provides automation and remote compilation. The plan currently looks like the following: 1. Document the existing approaches on automating the build system. 2. Write a build script that integrates with the obs-build repository. 3. Get security approval, as documented in https://github.com/openSUSE/obs-build/blob/master/HOWTO.add_another_format. 4. Verify the system works by testing on https://openbuildservice.org. I have already contacted zoobab (Benjamin Henrion), the mentor for this project and I have successfully verified that cascading Docker images successfully compile a package.

<p>OONF (OLSRv2) is a link state routing protocol. It works sending periodical messages to his neighbors with the aim of transmitting information about topology changes. With these information each node of the network is able calculate the paths to reach any other destination. These messages are periodically generated, based on the configuration parameter that regulates the sending interval. A short period will make the network react rapidly but it will also cause a large overhead due to control messages. Pop Routing is a recent technique that takes advantage of the knowledge of the network topology to find the optimal value for the OONF’s timers. Using Pop Routing every node computes its own “betweenness centrality” and uses it to calculate the optimal trade-off between convergence and overhead. The algorithm has been developed at the UniTN and the needed libraries to compute the BC are available as free software. My goal is to build a daemon that can calculate autonomously the BC of the network, together with a plugin for OONF that will use this value to tune its timers.</p>

<p>The AcousticBrainz database contains detailed high and low-level information for millions of audio recordings, all of which create an essential for creatives, researchers, and music fanatics alike. Our understanding of audio can be greatly improved through features that focus on similarities between the content of recordings in such a large database. As such, the development of a similarity index between recordings is essential to improving the AcousticBrainz platform and also to the progression of music recommendation engines in related projects like ListenBrainz.</p> <p>Especially in relation to AcousticBrainz, previous investigations on similarity systems have supported the success of content-based (high and low level data) engines for determining track similarity. These implementations have fallen short since their architecture prevents scalability, ultimately lacking the speed required for use in AcousticBrainz.</p> <p>With the information gained from previous pitfalls in recording similarity research and the importance of improved efficiency for a long term implementation, my 2019 GSoC project aims to lay the foundation for an AcousticBrainz similarity engine.</p>

<p>Quark-Engine is a rule-based android malware detection tool, However, as a contributor of both Quark and its side projects (quark-rule-generate, ruleviewer), we know that Quark currently faces a problem of insufficient number of detection rules. Although Quark-Engine has a side project for automatically generating rules, the performance of generating detection rules is still low, and the multi-process technique used in this project still has problems. Thus, my first object of this proposal is to develop and implement a new strategy for the rule generation technique to improve the efficiency of rule generation and solve the multi-process issues.</p> <p>Furthermore, the Quark team is now executing a strategy called “Quark Everywhere” which is to expand the influence of Quark among security open source projects. Thus, my second object of this proposal is to help Quark-Engine integrate with other security open-source projects and improve user experiences of Quark-related functionalities to the integrated projects (APKLab, Jadx).</p>

Modern messaging platforms like Discord and Slack are not just used for communication but also for consuming news, discussions, and topic-specific updates. However, keeping track of all this information across channels is overwhelming. This project aims to build a privacy-preserving, offline desktop AI assistant that can retrieve and summarize past messages using a local Retrieval-Augmented Generation (RAG) pipeline. Leveraging Intel's OpenVINO 2025 Generative AI workflow and LangChain, the assistant will extract messages via the Discord API, embed them using OpenVINO-accelerated models, and store them in a FAISS vector database. On receiving a user query or generating a daily digest, the system retrieves relevant context and runs inference using a locally optimized LLM, accelerated by GPU, NPU, or CPU depending on available hardware. A PyQt-based desktop application server as the user interface, providing features like chat, digest summaries, model/device selection, and system notifications.