Explore Projects

A Collective Cognition Model to serve as automated guidelines to open source communities. The model will project the activities, interrelationships, to keep the community self-sustaining and to help people stay in the community and become contributors. This will be validated by the data generate by an Agent based model and will serve as a verification component.

<p>Integrate Enzyme into Rust to provide high-performance differentiation of generic Rust code.</p>

<p>The main purpose of this project is to make the text-editors of coala more robust and active. This will be done through ensuring that the plugins are up-to-date with proper tests and continuous integration, to make maintenance more simplified for contributors in the future. This project will be completed through the use of several open-source tools. Further, the completion of this project will lead to other developers having the freedom to use coala in their favourite text editors. The ease of usage in different text editors may also help potentially serve as a way to popularize coala.</p>

<p>Apache DRAT is an open source Release Audit Tool. Which is distributed and parallelized (Map Reduce) wrapper around APACHE RATTM (Release Audit Tool) that goes far beyond RATTM by leveraging Apache OODTTM to dramatically speed up the process. Currently DRAT has two GUIs, the first one proteus which has the all four commands available in CLI drat tool and a summary view workflow GUI screen. The second one is Viz which is mostly a summary View. Both tools have problems showing errors from background process because most of the commands run as a process wrapper. The objective of this project would be to combine both of the GUI web apps features in to one and give more productive single GUI.</p>

<p>As a Ph. D. student in a computational chemistry research group involving crystallography, I’m very familiar with many of the features and functions that crystallography groups need from a molecular editor. Although Avogadro 2 has some basic unit cell building and visualizing, it is missing a lot of key functions that crystallographers use in Avogadro 1. Identifying the spacegroup of a crystal, converting a crystal to a conventional or primitive cell, symmetrizing a crystal, and filling a unit cell are all important features that crystallographers need when working with crystals. Thus, while being careful to avoid licensing issues with external libraries, my primary goal is to advance the materials applications in Avogadro 2 by first incorporating these features that were present in Avogadro 1 and then eventually incorporating new features that can be useful for crystallographers.</p>

<p>GNOME Keysign is a project that got started from the idea to make people more involved and interested in creating trusted “connections” by using digital keys. Therefore, this application is meant to ease the entire process of signing OpenPGP keys so that more people can use it regardless of their GnuPG knowledge.</p> <p>GNOME is pushing the envelope when it comes to balancing security, functionality, and usability. This project is about bringing a GTK Builder based UI to GNOME Keysign as well as investigating what's missing for it to become an xdg-app.</p>

smartmontools (smartctl) is a widely used tool for collecting SMART metrics from storage devices (SATA, SAS, NVMe). However, its runtime metadata file, drivedb.h, suffers from inconsistent labeling of attributes such as SSD wear, endurance, and temperature, which hinders meaningful monitoring and integration with observability tools like Prometheus/Grafana in environments such as Ceph clusters. This project proposed a two-part solution. First, I added interpretation logic in the smartmontools C++ codebase to normalize metrics (e.g., converting wear remaining to wear used as 100 - value) and expose them under a consistent JSON key. Second, I developed regex-based classification and drafted a standard spec to map freeform SMART attribute labels in drivedb.h to a consistent set. Together, these changes improve data reliability and facilitate integration with monitoring dashboards. Deliverables include: Interpretation logic enhancement in the smartmontools C++ source Regex-based normalization rules & classification Documentation of a SMART attribute label standard Test builds and reports from real SSD validation

The goal of this project is to address the challenge of checkpointing distributed applications, which generally run across multiple nodes with active TCP connections. While Kubernetes has recently introduced checkpointing support, it lacks a proper synchronization mechanism for distributed workloads, especially in managing network state during checkpoint and restore. To solve this, the project proposes to extend the existing criu-coordinator tool with support for network connection management via CRIU’s hook mechanisms. The work will involve implementing network-lock and network-unlock hooks, developing a pod-level network locking mechanism, and differentiating between internal and external TCP connections during checkpointing.

In this GSoC project, I worked on developing a multimedia processing system, focusing on commercial detection and replacement using deep learning. I have developed a real-time, efficient solution that enhances media consumption experiences by seamlessly integrating custom audio streams during commercial breaks.

The aim is to construct bidirectional dictionaries for a language pair, given a pair of parallel corpora - i.e., the same content in two different languages using a single script that does the job for the user in a single step, unlike the current method that requires multiple steps to do the job. The final deliverable is a Python script that does the job in one step.

MLFlowClient.jl lacks of updates regarding new features coming from the original Python package. Some effort is needed to ensure new version methods. My plan is to implement that novel features using pure Julia, increasing compatibility; and also new functionality to allow communication with MLJ.

Many applications of point set surfaces work with noisy point sets, requiring a denoising operation to reconstruct the original surface. This project will implement constraint-based point set denoising-- an iterative, anisotropic denoising algorithm presented by Yadav et al. While denoising algorithms exist in CGAL, this method focuses on preserving sharp geometries during the denoising process. The final deliverable for this project will contribute to CGAL's Point Set Processing package.

This project is dedicated to streamlining and enhancing the CircuitVerse development experience. Our primary objective is to simplify the setup of the development environment and streamline the coding process, ultimately making it more efficient. Furthermore, we aim to bolster the quality of our test cases and optimize the continuous integration (CI) workflow, which will, in turn, reduce the time required for code reviews by our maintainers. -- Throughout this project, our key objectives include: 1. Integrating the Ruby Debugger 2. Incorporating Solargraph Language Server Protocol (LSP) and Crafting YARD Documentation 3. Integrating Vite Rails for Improved Development Workflow 4. Incorporating RBS in the Project and Implementing Static Type Checking in CI 5. Implementing Undercover CI for Enhanced Code Coverage Analysis 6. Enhancing Unit Testcase Coverage 7. Adding Missing Integration Testcases 8. Enhancing the Remote Development Platform (GitHub Codespaces, Gitpod) 9. Improving the Docker Development Setup 10. Enhancing Setup Documentation for Developers

In this project, I am going to make a neural network which is going to predict the probability that one satellite will collide with another. With this information, I am going to compute what area of ​​the earth may be affected by this collision.

Generics are a common functionality found in statically typed programming languages, allowing easier maintenance of programs which differ only in their types. However, generics are not yet supported in the statically-typed LPython. Generics in LPython can be implemented similar to the approach taken by C++ templates. We can regard generic functions as functions with type parameters, whose parameters are made concrete and checked by function calls on AST level. The end result of the project would be generic function support for LPython with option for specialization, along with sufficient integration tests and documentations.

The project aims to build an application to run a workload container on a bunch of flotta-configured edge devices which collects/processes input from a webcam feed with basic processing capabilities like image classification and object detection and sync these images from the device with object storage. Running cluster side container app which would present aggregated results using a web framework. As an example for this kind of application, a Python based application will be developed which will perform the image classification using state-of-the-art machine learning models and later progress with syncing these images with an object storage. Next the images can be browsed using webapp running in a cluster.

Oppia frontend codebase is fully typed, but our typing doesn’t yet pass strict TypeScript checks. This means that variable assignment, procedure parameters, and function return values will all be clearly connected with a type. Strict is a typescript compiler option that enables a set of tougher type rules that, when enabled, assist lower the possibilities of producing surprising outcomes and make the code more resilient, but Oppia's code base presently fails to pass these stringent requirements. As a result, the code is vulnerable to unexpected actions and failures. To avoid this, modify the strict TypeScript config file such that all newly-added files must be strictly typed, and Introduce strict typing for about 280 twins of files, as well as tests for those files (for a total of 560 files), and ensure that no more unknown type is used, as well as removing all unknown type usage from the newly strictly typed files. The document also lays out the whole implementation approach for the idea, as well as the milestones I'll need to fulfil to finish this project.

The main objective of this project is to develop an Android application to help companies or competent authorities and farmers to detect certain crop illnesses on the terrain and display the localization of the trees and terrains affected by the crop illness on the liquid galaxy to help them monitor the evolution of such illnesses throughout the territory. The problem will be solved through an android application with a machine learning model that will detect the illness of the samples. After that, the location of the sample will be recorded, and the coordinates will be displayed on the liquid galaxy. The deliverable will be an android app that will do anything that has already been commented on.

I would like to be a part of drupal.org in GSOC. The project Decoupled menus for Drupal. Which is the concept of making Drupal combined with New technology react. The two use cases which were used in the description were much interested. I was learning with the react over the past 10 months. So I would like to solve the problem in a good manner like combining the react with PHP or Python. So, First of all, they asked us to build a menu section that should be globally active around the other pages. This can be done by the react components. Which I had the idea of doing it. In the second use case, they asked to create a menu(s) that changes from page to page like the "Content Moderator Shortcuts" menu to the "moderator" role. Which we can implement with React router dom. But the main task of this objective is to combine the react with drupal. While we know Drupal still serves as a backend repository, front-end frameworks can talk to the database via API calls. By making the Make a stand-alone front-end and using drupal to create APIs which interact with the database. Then consume the API through HTTP AJAX or whatever mechanism React Js contains. Yeah, while coming to symphony it's been a task for me to learn it for using it as a framework. I have already had a little experience with the laravel framework. I am keen interested and fully fledge to be a part of this project.

<p>Implementing an <strong>in-proxy authorization cache for envoy proxy using web assembly and proxy-WASM rust SDK</strong>. The cache will be in synchronization with 3scale Service Management API by periodically flushing the local cache snapshot and updating the local cache with a new cache snapshot provided by 3scale Service Management API. When a HTTP request is received by the proxy, it will do a look up in the cache to check whether a cache record exist for that particular request. If a record exist, then perform authorization logic based on that request <strong>(cache hit)</strong> . If a cache record does not exist<strong>(cache miss)</strong>, do a HTTP call to 3scale Service Management API to fetch relevant authorization data, add the records to the local cache for any subsequent requests and perform authorization based on the received data. For the project, <strong>a request intercepting HTTP filter</strong> and a <strong>singleton service that runs independently from request life cycle</strong> will be implemented using proxy-wasm-rust-sdk and will compile them as web assembly modules to extend envoy proxy with the HTTP filter and singleton. <strong>Web assembly modules allow us to extend envoy without building the envoy static binary using bazel build system.</strong></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>

<p>I plan on developing the Bhojpur-Hindi language pair in both directions i.e. bho-hin and hin-bho. This will involve building a monolingual dictionary for bho and the bho-hin bilingual dictionary. The next step would be morphological disambiguation and writing suitable transfer rules to bring this pair to a releasable state.</p>

<p>Create and test pre-sorting methods of z-order and Hilbert curve for elements in GiST index to check if it will improve the performance of index building process.</p>