Explore Projects

<p>This project aims to design and integrate the integer “Multiplication and Division Unit (MDU)” with SERV core as a co-processor. The MDU will support all of the instructions that are provided in <code>The RISC-V Instruction Set Manual. Volume I: Unprivileged ISA</code> chapter 7, M-Standard Extension for Integer Multiplication and Division, Version 2.0”. This MDU is to be designed in a way that it would use most of the DSP resources on the targeted FPGA board and it would be generic and parameterize so that it can easily be integrated with any of the RISC-V core.</p>

<p>The Apache VXQUERY processor is responsible for parsing and querying large amounts of XML documents. The XML format is currently used in a variety of ways such as representation (HTML), enabling data exchange between services (SOAP, REST), etc. An alternative to XML is the JSON format which is widely considered significantly more lightweight. Thus, the goal of this project is to add support for parsing and querying JSON data based on the JSONiq language specification to the VXQUERY project. Specifically, we want to add arrays, which is one of JSON items in the VXQUERY data model.</p>

gccrs is a full alternative implementation of the Rust language ontop of GCC with the goal to become fully upstream with the GNU toolchain. One of the steps to reach its implementation counterpart's parity (rustc) is the support of inline assembly. Enabling this feature allows programmers to work on low level situation where some extra performance is always needed. The project focuses on adding implementation for two built-in Rust macros: asm!(), and global_asm!(). The gcc compiler will be able to detect parse the assembly code within asm!, and global_asm! macro, converting them to gcc assembly format to eventually generate code.

<p>JuxtaPiton is an architecture being developed at Princeton’s Parallel Group for heterogeneous ISA research. For this project, I will replace the existing PICORV32 core with the open-source ao486 core to have x86 ISA support along with the OpenSPARC T1’s SPARC V9. This kind of a heterogeneous system enables reuse of a lot of legacy x86 code. We also try to interface the L1 cache level of ao486 with the L1.5 cache subsystem of OpenPiton. This allows us to harness Piton’s P-Mesh subsystem which maintains cache coherency across both the cores.</p>

The rise of ARM processors has created new binary targets for pre-compiled executables. Additionally, there are tales of widespread use of operating systems that aren't linux? In the ideal case a `pack` user could create a build for an abritrary architecture and operating system, regardless of the host system they used to run the command. Expected outcome: Improved multi-architecture (including ARM) and multi-os "cross-compilation" support in [pack](https://github.com/buildpacks/pack/) Upstream Issue (URL): https://github.com/buildpacks/pack/issues/1459 and https://github.com/buildpacks/pack/issues/1460

This project aims to support the detection and reporting of SPDX License Expressions. Currently, FOSSology uses regular expressions, full-text match, and fuzzy match to scan licenses, stores all types of license expressions as a list of licenses, and wrongly classifies them as conjunctive licenses or disjunctive licenses. It also stores license exceptions as licenses and does not differentiate exceptions from licenses. In the project, I will be working on scanning license expressions using regular expressions with Ojo, storing them in the database, creating UI components to see license expressions in the file clearing page, and finally updating reports to export the expressions in the correct format.

KubeArmor has garnered interests from edge computing platforms (such as LF Edge OpenHorizon) that leverages k8s control plane for workload orchestration. The primary requirement is to support ARM platforms that are prevalent on the edge devices (especially Raspberry PI). KubeArmor leverages eBPF for observability and Linux Security Modules (such as AppArmor) for policy enforcement. One of the challenges is to check if the eBPF primitives such as observing kprobe, kretprobe, tracepoints that are typically available on the x86 platform are also available on the ARM platform and check if the parameter list fulfills the requirement. Post this analysis, the KubeArmor code might have to be changed to accommodate any differences in the eBPF behavior.

The most efficient algorithm to sample from a log-concave distribution, that volesti supports is the Hamiltonian Monte Carlo with leapfrog integration. The leapfrog method is an Euler method that in each step evaluates the gradient of the log-probability density function of the target distribution. To sample from a log-concave distribution volesti currently requires a function that evaluates this gradient as an input. However, there are plenty of applications that require sampling from a distribution where the gradient of the log-probability density function is unknown. This project will address this problem and will provide to volesti routines of automatic differentiation of a multivariate function. Then, a function that evaluates the log-density will suffice to sample from the target distribution.

This project aims to allow using dynamically loaded Clang plugins on windows by adding support for building LLVM and Clang as shared libraries on Windows with all the public c++ API exported and dynamically linking to them. Part of the process will be automated with a tool built using the Clang tooling API to automatically add export macros on the appropriate class and functions declarations in llvm public headers. Deliverables: End users can use custom clang plugins with official windows build of Clang. The llvm windows binary install size can be greatly decreased by dynamically linking llvm tools to the LLVM and Clang shared libraries.

<p>The current version of Pocket Code doesn't have support for <strong>particle physics</strong>. This project proposes to implement and integrate a particle system that would allow the addition of smoke, fire, and other such particle effects in the games! The visibility, position, type, velocity, color, and other such properties of the particles could be controlled using the new "particles" bricks that will be added as part of the project! This will enable effects like a glowing effect around coins and collectibles, glowing trail behind fast-moving objects like a ball or a meteorite, flames, smoke, explosions, etc. giving much greater freedom and control to users and allows them to let their creative juices flowing!</p>

Optical Character Recognition (OCR) technology has revolutionised document digitization, converting printed and handwritten text into machine-readable formats. However, recognizing text from centuries-old works remains challenging due to the complexity of early non-standard print forms, handwritten texts, and manuscripts. Existing OCR tools like Adobe Acrobat and Google’s Pytesseract OCR often struggle with historical documents due to variations in font styles, image quality, degradation, and layouts. This project aims to develop a hybrid end-to-end Transformer model capable of accurately recognizing text from non-standard Spanish printed sources from the 16th and 17th centuries.

Linux kernel is the largest open source project with 2+ million lines of code and 10,000 developers across the globe. It is a challenge to understand how the community works, how to get started learning the code base, and take steps to become a contributor. This project will help the applicants help navigating the code base, community, and guide them in choosing the areas of the kernel, finding kernel bugs to focus on, and developing a solution working with the experts in the community. After the end of the project, the applicant will have a much deeper knowledge of many different areas of the Linux kernel and get their patches accepted into the kernel.

This project extends the Accord Project Template Playground by implementing an end-to-end, sandboxed logic execution pipeline to solve its inability to test interactive smart contract behaviors natively. By utilizing a secure Web Worker architecture, the platform will safely evaluate user-authored TypeScript logic and validate all states and requests against strict Concerto models directly in the browser. The core deliverables include an integrated Monaco-powered logic editor, an interactive contract runner UI for initialization and request handling, dynamic execution results visualization, and comprehensive multi-state contract templates. Together, these features transform the platform from a static authoring tool into a complete, interactive development workspace for smart legal contracts.

The objective of this project is to provide alias support in concerto language . For example import statement like "import {document as d} from Library" to be supported by the end of this project. This would allow us to import two models with same name in a single file by aliasing them to different names which is currently not supported in the language. Doing this would require changes in both the concerto-parser and concerto-runtime . The project requires compiler design and programming language knowledge. The stack used in project is NodeJs and written in typescript. The concerto-parse is written in PEGJS.

Problem: Currently, Joomla items such as articles are limited to a single category, which makes it difficult to organize content that belongs to multiple contexts. While tags are sometimes used as a workaround, they do not integrate with core features such as routing, menus, and structured layouts in the same way as categories. Solution: This project introduces multi-category support by implementing a generic mapping table (#__category_item_map). It preserves backward compatibility and SEO integrity by using a "Primary Category" as the main reference for routing, workflows, and parameter inheritance. Deliverables: A new database schema, an updated backend interface for multi-category selection, frontend updates to reflect multi-category assignments in item views and category listings, model-level integration for custom fields, extended batch operations, unit tests, and documentation.

Workbench is a multi-language code sandbox for GNOME. It is prevalent in the GNOME Ecosystem and is helpful to both professional and amateur developers. It provides a sane environment where you can quickly iterate on code in a GNOME application without going through the usual slow recompile cycles. Typescript is a language developed by Microsoft that adds static type annotations to JavaScript. This language has been trendy in the JavaScript/Web Development industry, and recently, we have seen projects like ts-for-gir that allow TypeScript to be used to build GNOME applications. Adding TypeScript support to Workbench would help developers write more robust code instead of the usual fragile JavaScript and help GNOME app developers get the most out of the growing TypeScript ecosystem by using new and modern features and syntax like decorators, iterables, etc.

<p>XMPP RFCs and Specifications define connection establishment over TCP, BOSH and websockets. Smack currently establishes connection between Server and Client using TCP and BOSH. BOSH suffers from high transport overhead as compared to TCP. Also various issues with long polling are suggested to have an impact upon BOSH based systems [RFC 6202 Section 2.2]. WebSocket provides an alternative to the limitation of inefficient communication between the server and the client by providing bi-directional, full-duplex, real-time client/server communications. The protocol consists of an opening handshake followed by basic message framing, layered over TCP [RFC 6455]. Adding WebSocket support to Smack will allow it to establish a continuous Client-Server connection with less overhead.</p>

Java PathFinder (JPF) is an extensible software analysis framework for java bytecode which can be used to check for concurrency defects like deadlocks, and unhandled exceptions like NullPointerExceptions and AssertionErrors. Symbolic PathFinder (SPF) is its extension that enables symbolic execution of java programs. This proposal outlines my plan to contribute to The JPF Team by working on the Support portfolio of solvers in SPF Project during Google Summer of Code 2025. The main goal of this project is to enable the simultaneous invocation of multiple constraint solvers, where execution halts as soon as any solver returns a satisfactory result. This approach is expected to enhance SPF's ability to handle a broader range of constraints. This Project will extend SPF branch sv-comp. The outcome will enhance SPF’s scalability and applicability in symbolic execution tasks.

<p>Injection attacks are still the most common type of vulnerabilities found in software, SQL injection is one of them, it exploits the lack of sanitization of the user input when performing database queries, the goal of the project is to enhance SQL injection support in the metasploit framework, to make it easier for module writers to implement SQL injection attacks.</p> <p>In order to accomplish that, I will be implementing the common SQL injection attack types (including blind injections), and adding a level of abstraction, where I handle retrieving the table and column names, and other informations, on the different database management systems.</p> <p>People developing SQL injection exploits with metasploit will no longer need to implement the binary search required to do blind SQL injection, or measure timing in time-based attacks, or prepare a query that depends on the DBMS to retrieve the table names.</p>

<p>Rizin currently relies upon manually writing code for adding a new CPU or an IO port. This implementation is unfit as the vast and growing ecology of hardware components such as CPUs and SoCs regularly implement a part of architecture with custom instructions, registers, and address configurations with trivial differences, making it infeasible to maintain all of them inside Rizin.</p> <p>Providing a level of abstraction in handling this entropy in embedded systems, by supporting editable CPU and platform profiles is the goal of this project. This will also make adding and maintaining these ports easier with less interaction with Rizin’s core. This project also aims to add more flexibility in having a way of importing existing hardware data description documents so that reverse engineering on particular chipsets is easier. This will also help us to memory map the peripheral accesses and registers to provide a better reverse engineering experience. This, in turn, could also be extended to benefit Rizin in terms of compatibility and the end users in terms of user experience.</p>

The main goal of this project is to add support for handling runtime exceptions in SPF that will improve SPF's performance on SV-COMP benchmarks. There are two main reasons why SPF is losing many points in runtime exception verification tasks. First, SPF is not systematically exploring execution paths where symbolic variables could lead to runtime exceptions like NullPointerException and StringIndexOutOfBoundsException, resulting in many incorrect false results where actual exceptions are not detected. Second, the SV-COMP execution script is lacking proper property detection and result classification for runtime exception scenarios. To address these problems, we should extended SPF to have additional choices that will explore potential runtime exception scenarios when symbolic variables could represent values that can raise them. To deal with this, we can analyze why SPF outputs wrong answers for certain verification tasks and fix them. This systematic approach to runtime exception path exploration will help fix SPF's behavior, improving its scores on SV-COMP benchmarks. This project extends the SPF branch, sv-comp.

<p>coala is a linting and code fixing tool with support for many languages. Having a configuration file is essential to make full use of coala. Having a standardised configuration format like TOML helps. coala currently has an INI style configuration. Also, INI style configuration has certain limitations when it comes to custom sub-level parsing. The LineParser and ConfParser becomes complex and error-prone. This project will allow developers to quickly implement new features and will allow users to write configuration files in a format that they are already familiar with.</p> <p>This project would focus on :</p> <ol> <li>Allowing the user to create configuration files in TOML</li> <li>Providing coala with the functionality to create TOML configuration files from sections</li> <li>Creating a tool to convert .coafile to TOML configuration file</li> <li>Allowing coala-quickstart to generate configuration files in TOML as well.</li> <li>Creation of TOMLLintBear and a repository of good configuration files to allow users to easily bootstrap their projects.</li> </ol>

<p>Semantic saliency detection be implemented based on CNN module. Quantization method described in <a href="https://petewarden.com/2016/05/03/how-to-quantize-neural-networks-with-tensorflow/" target="_blank">Pete's blog for quantization</a> will be added into project <a href="https://github.com/nyanp/tiny-cnn" target="_blank">tiny-cnn</a> together with deconvolutional functions. This project will be the dependency of OpenCV afterwards. There is also an IOS APP demo for such tiny deep learning structure.</p>