Explore Projects

Project Description: The existing completion functionality for cargo commands is achieved through the maintenance of a completion script. This script is difficult to maintain and cannot be easily ported across different shells, with each shell requiring its own specific completion script. How to solve: This project aims for the completion script to call an external completion program, thereby realizing the implementation of the completion functionality in Rust language, instead of shell completion scripts. Rust will bring various advantages such as safety, testability, portability, and ease of extension. Deliverables: 1. Implement a stable and easy-to-use dynamic auto-completion script generation module for the clap project. 2. Implementation of cargo dynamic completion feature. 3. Testing the cargo dynamic completion feature

<p>Unlike proposed, I will evaluate Clang's ThreadSanitizer as well as the AddressSanitizer as these two sanitizers seem more pressing to the Mono community. First, I will look into ways to inject these sanitizers into the Mono runtime and get a feeling for the feedback that they provide. Depending on the feedback, I will then try to fix races / overflows myself or - at least - file bug reports and discuss those issues with the community. Besides working on the races and overflows themselves, I plan to write two articles for the website; one of the articles should explain using the ThreadSanitizer in combination with the Mono runtime and the other one should explain the AddressSanitizer.</p>

<p>This project includes adding BLAS, Sparse linear algebra and iterative solvers into Chapel.</p>

<p>In Data Science acquiring insight from data is what matters and any good data analysis tool must have the key functionalities required to extract information from data. Now, it’s needless to say how ubiquitous categorical data is in Data Analysis but they are not currently supported in Daru and operations on them like regression is not supported in Statsample and Statsample-glm. This shortcoming of Daru prevents data to be easily and to its full extent analyzed. This project aims to achieve just that.</p> <p>This project has broadly two goals:</p> <ul> <li>First is to efficiently store and manage categorical data in a Data Frame. This will be done with the help of a new data type CategoricalData and a class CategoricalIndex dedicated for this purpose. It also involves easy visualization of categorical data with help of plotting functionality.</li> <li>Next goal is to update various statistical analysis such as regression in Statsample and Statsample-glm taking categorical data into account.</li> </ul> <p>On accomplishing both of these tasks, one would be able to see Data more clearly.</p>

<p>Currently CVE Binary Tool’s binary scanning is slow and a software manifest of known packages can be used for quick scanning for CVEs as an early warning system. Here a database is built primarily of top packages from PyPI and the core packages of popular Linux distros like Ubuntu, Fedora, CentOS etc. and a parser that reads the packages from the list and maps them with the database. The checkers for these packages are created alongside.</p> <p>Also to improve user experience the creation of a backported fix checking utility can be made. It checks the packages with CVE in the scan and a database with the data including backported fix and provides an output if the CVE is fixed.</p>

<p>strace currently adds significant overhead to any application it traces. Even when users are interested in a handful of syscalls, strace will intercept all syscall made by the observed processes, involving several context switches per syscall.</p> <p>Since Linux 3.5, userspace applications can rely on seccomp-bpf to filter the syscalls they want to trace. In that case, the set of monitored syscalls is filtered in the kernel, using cBPF, before any context switch to userspace. strace could leverage seccomp-bpf to avoid tracing syscalls users don't want. The tracing landscape of Linux also drastically evolved in recent years. In particular, user applications can rely on eBPF programs to filter and aggregate data of interest in the kernel, with low overhead.</p> <p>During this Google Summer of Code, I will finish and merge the works started to 1) rely on seccomp-bpf to filter syscalls in kernel space and 2) allow strace to use alternative backends. That second work will come with a tracepoint/BPF proof of concept to ensure strace supports diverse backends, beyond the usual ptrace model.</p>

<p>This proposal will add more convolution operations to aid the users rather than implementing these operations on their own.These operations would be a great addition to not only Theano but also the libraries that are built using theano like Keras and Lasagne.This project will also implement a meta-optimizer on the new gpu-backend which will choose the fastest convolutions from the many available, thus running these operations as fast as possible.</p>

<p>The aim of the project is to ease the process of creating a new Lint Bear, addressing the issue of linting files having embedded source code and provide command line interface improvements to existing coala application.</p> <p><a href="http://mr-karan.github.io/2016/08/13/coala-GSoC-2016-Summary.html" target="_blank">http://mr-karan.github.io/2016/08/13/coala-GSoC-2016-Summary.html</a></p>

This project adds a new dump option to gcc that dumps GENERIC trees as JSON. We also add some plumbing into gcc's gdb hooks that allow one to browse a generic tree as a single HTML file. This project is based off of this patch: https://gcc.gnu.org/pipermail/gcc-patches/2024-February/646295.html

Exception handling in GCC follows the Itanium ABI, particularly the C++ exception handling ABI. This process involves creating, throwing, and finally destroying the exception object. The strategy employed is known as the Zero Cost strategy, which aims to minimise the impact on the main program execution path. It achieves this by pushing all exception handling operations into separate side tables, thus avoiding any potential negative effects on the instruction cache. When an exception is caught, GCC utilises DWARF information to unwind the stack, allowing the program to resume execution at the appropriate point. However, one current limitation is that GCC does not track the specific type of exception that is thrown. This project aims to improve the nothrow detection in GCC which will allow to eliminate the dead exception handling regions and thus optimise the intermediate code generated.

SQLite is widely used in mobile, desktop, and edge applications but has no production-ready Change Data Capture connector. This project builds a Debezium source connector for SQLite that captures row-level changes by directly parsing the SQLite Write-Ahead Log (WAL) binary file by decoding B-tree leaf pages, diffing old and new page states, and producing standard Debezium change events with correct before and after values, without any application modifications. Deliverables include a deployable Kafka Connect plugin with full WAL binary parsing, initial snapshot, streaming with safe checkpoint lifecycle management, transaction metadata support, and a complete test suite with documentation.

<p>To introduce open-source IP for components such as an NASTI slave memory mapped DDRx controller.</p>

<p>Mission Support System is a flight planning software which a researcher can use to analyze predicted atmospheric data, and plan a flight-path with 3D way-points. The software in the present state allows editing by a single user per flight-path. To share this work, one has to export the work as a <code>$name.ftml</code> file and send it to other researchers for further planning. This back and forth communication not only consumes a lot of human efforts and time, but also can be frustrating when the number of researchers involved in a project is bigger, say &gt;=3.</p> <p>I propose a solution to this problem, the development of <code>Mscollab</code> which stands for "Mission Support Collaboration". <code>Mscollab</code> server would facilitate <em>real-time</em>, <em>collaborated</em> editing of flight-paths by <em>authorized</em> users. By design, it will also provide a chat facility for the users who are collaborating on the project. Its UI would be a part of <code>msui</code>, the core User Interface module of <code>mss</code>. It would additionally provide insights about temporal changes related to waypoints and the users who created them, for analytics purpose. <code>Mscollab-server</code> will be a standalone server built with Python, Flask, and python-socketio.</p>

<p>I would like to complete the QtSharp project which aims to provide Mono/.NET bindings for Qt.</p>

Professional-grade cameras capture photos in a raw format before being processed into actual pixel data by a photo editing application. The Rust ecosystem lacks a library for decoding and processing raw files that meet's Graphite's requirements for being modular, pure Rust, and permissively licensed. This project aims to develop a crate that will enable Graphite to begin its growing focus on the envisioned photo editing feature set.

<p>The project PyAfipWs under Python Argentina(PyAr) is a library for Developers &amp; tools for accountants and SMEs.PyAfipWs contains Python modules to operate with web services regarding AFIP and other government agencies, mainly related to electronic invoicing, several taxes and traceability.About the project - : The idea is to merge back changes from previous GSoC, convert to UTF-8 &amp; fix encoding issues, add unit tests with upto 85% coverage, convert scripts into python entry points, resolving problems arising in setup.py , support for dbf tables, xml, xls sheets and possibly other libraries, integration &amp; deployment with github actions to upload to pypi automatically and use of pytest VCR for unit test.These are all things that would help in the development of the project.</p>

<p>This project aims to design and implement support for encrypted mailing lists into GNU Mailman using PGP/MIME and GNUPG.</p>

This project aims to enhance the testing of the Wild linker by leveraging existing linker test suites, providing strong support for its development. Develop some programs that apply existing linker test suites to Wild, automatically categorizes the results to some extent, and visualizes them in a format that allows Wild developers to easily review them. Subsequent work will focus on a variety of improvements to Wild, including adding support for new architectures, fixing existing bugs, implementing new features, and more.

<h3>Project goal</h3> <p>The goal of this project is to devise and implement a simulation-ready memory controller dedicated to benchmarking processor cores implemented on field programmable logic, that will produce delays much closer to a system where the memory interface is running at a much slower clock speed. This can take two forms.</p> <ul> <li>A simulation model for a memory controller that is tunable.</li> <li>A synthesizable module to be placed between the soft core implementation and an existing non-tunable DRAM controller.</li> </ul> <h3>Novelty and benefits to the community</h3> <p>So far, papers have been reluctant to provide accurate processor core performance figures extrapolated from FPGA implementation because DRAM controllers have an unrealistically high clock speed clock speed relatively to a soft core, compared to an ASIC core implementation. Providing the community with open source tunable memory controller models dedicated to the benchmarking of soft cores will greatly help producing more accurate and interpretable core and accelerator performance figures without requiring an ASIC tape-out in the first place, which is often not even an option.</p>

<p>The proposed project is to create a set of Python based tools for easier and efficient creation of Hypermedia driven REST-APIs.</p> <p>The other part is an application that simulates the movements of a flock of drones that have as objective to detect the presence of fires or abnormal heat spots in a given geographical area using an infrared sensors to demonstrate the capabilities of Hydrus and the Hydra Draft.</p>

<p>Provide a distributed implementation of the Linear Algebra package in Chapel, which is currently restricted to a single node/locale</p>

This proposal focuses on developing two essential tools using Flutter: the Unicode Character Visualizer App and the Multilingual Text Rendering Tester App. Problem Statement Many developers, designers, and linguists lack accessible tools to browse Unicode characters, view detailed metadata, and compare how multilingual text is rendered across devices and fonts. Text rendering inconsistencies often arise across platforms, impacting accessibility and readability. Solution Unicode Character Visualizer App: Provide a comprehensive and interactive platform to search and visualize Unicode characters. Display essential metadata such as codepoints, descriptions, and language support. Offer font rendering previews for accurate character representation. Multilingual Text Rendering Tester App: Allow users to input multilingual text and visualize rendering differences across various fonts and devices. Benchmark rendering performance and identify inconsistencies. Deliverables Fully functional Unicode Character Visualizer App with search, character details, and font rendering features. Multilingual Text Rendering Tester App with input comparison, font analysis, and reporting functionalities. Comprehensive documentation, including user guides and API integration manuals. Well-tested codebase with unit, widget, and integration tests. This project will contribute to Unicode, Inc. by providing essential tools for ensuring Unicode character accuracy, supporting linguistic diversity, and improving cross-platform text rendering. I am excited about the opportunity to collaborate and contribute to the Unicode ecosystem.

This project aims to implement an in-memory, volatile file system for NVIDIA GPUs using the NVPTX backend in newlib. NVPTX offloading in GCC enables running tests on the GPU, but currently lacks proper file system support. The proposed solution involves two key objectives: (1) developing a lightweight file system driver that operates in the GPU’s VRAM, and (2) redirecting NVPTX system calls in newlib to interface with this in-memory file system. The file system will support basic operations such as file creation and deletion, without requiring recursive directory structures. This work will improve the runtime environment for NVPTX targets and potentially pave the way for future extensions, such as RPC-based host filesystem access or support for AMD GPUs via the AMD GCN backend.