Explore Projects

<p>Rivet is a software package for performing data analysis on simulated particle collision events like those in the Large Hadron Collider. This project will focus on making Rivet performant on modern CPU architectures in HEP and HPC compute facilities, particularly ensuring that the central result caching and dispatching system is thread-safe and amenable to vectorized compiler optimizations. We will be working to Improve the Rivet's computational performance, make it thread-safe, profile and optimize the expensive computational components and ensure continuity of physics behaviour via the Gitlab CI engine.</p>

<p>loklak is free software hosted on loklak.org which provides message search results from twitter in json format. loklak is a complete search engine back-end solution with a json api. Loklak’s API can be used to build twitter clones and client alike, one of them being loklak.net. One of the main features that’s pending in such a tool is the ease of tracking emojis and using it as a sentiment analyzer.If we are able to track the emoji and make a heatmap according to the country/area , we can easily identify the mood of the people around.This proposal focuses on building such a tool.</p>

<p>The aim of this proposal is to improve RetroShare incrementally during the summer in the following work lines:</p> <ul> <li>Semi-automatic RetroShare friendship suggestion based on phone contacts</li> <li>Semi-automatize JSON API code and documentation generation</li> <li>Multiple simultaneous heterogeneous network connection for each peer</li> <li>Improve RetroShare Android usability and performances</li> <li>Seamless key exchange via Quiet Modem</li> <li>Chat and messages multiple device synchronization</li> <li>Directories multiple device synchronization</li> </ul>

D’s current JSON libraries (e.g., Phobos’s std.json) rely heavily on dynamic typing, which sacrifices type safety and performance—critical drawbacks for systems programming. For example, parsing JSON data into a generic JSONValue container forces developers to manually validate field types and existence at runtime, introducing overhead and error-prone code. This project addresses these limitations and enables type-safe JSON processing with constant memory by building higher-level functionalities on top of jsoniopipe, which exemplifies the language’s strengths in compile-time function evaluation(CTFE) and introspection.

<p>This project aims at writing a library in C++ that provides and interface to octave files (.m) to interact with python modules in a more efficient way. It surely will intend to provide more functionality atleast in terms of catching exceptions and provide suitable error messages, if possible, by using callback functions to handle such situations. For the solution, I propose to use Boost.Python (if it’s acceptable in terms of License) because I already have worked with boost libraries (not with Python library but with some others) and I think boost can prove to be the perfect solution. I intend to fully complete the interface with Boost.Python and to modify every file to use it before end of GSoC.</p>

This proposal aims to implement new features to the Enrichment Table App. The major changes were adding Ring Charts, prediction of gene id column and organism using past network history, implementing various filters and redundancy removal mechanisms, and reciprocal node selection. Some other minor new features were adding the ability to generate enrichment map from current table data and adding a new logging mechanism to the app to provide clear error messages. Entire new documentation was written for new users to the app to guide them through project usage. The app was further improved by providing multiple bug fixes and GitHub action to generate a new jar on code push.

I propose to develop a comprehensive and accessible robot simulation system for the FOSSbot project, utilizing cutting-edge technologies and best practices to create a fully-functional and optimized simulator. The development process will involve careful platform selection, deep understanding of the FOSSbot robot and its components, as well as the creation of class-ready simulator stages for educators and students. To overcome future cloud deployment cost constraints, I suggest using a game engine like Unity or Godot to create a lightweight simulator based on WebGL and Web Assembly. Through extensive debugging and documentation, the final product will be an advanced and accessible robot simulation system that will benefit the FOSSbot community.

<p>loklak is free software hosted on loklak.org which provides message search results from twitter in json format. loklak is a complete search engine back-end solution with a json api. Loklak’s API can be used to build twitter clones and client alike, one of them being loklak.net. One of the main features that’s pending in such a tool is the ease of adding angular micro services and modularizing the existing application to run on micro services. Alongside the data store of loklak is magnificent and provides the ability to build IoT platforms using the loklak server. In this proposal I would like to enhance the service architecture of loklak.net and build a proof of concept IoT application demonstrating the capabilities of the loklak server.</p>

<ul> <li><p><strong>JAX</strong> as the latest machine learning library has all the advanced gradient techniques aided by acceleration of GPU/TPU and high-level modules for model prototyping.So it definitely is a faster alternative to <strong>numpy</strong> as it can use XLA engine and the JIT compiler.</p> </li> <li><p>The book “<strong>Probabilistic Machine Learning: An Introduction</strong>” is an amazing book for any level of machine learning enthusiast and the examples mentioned in the book are very accurate and helpful in analysing the ML algorithms and tools.</p> </li> <li>So the <strong>ML examples</strong> presented in this book can be a great pick to <strong>test and prove the potential</strong> of JAX and also helps to improve the library.</li> </ul>

DBpedia provides monthly releases produced by the DBpedia Extraction Framework. They are composed of various data artifacts that mainly stem from the wiki dumps. However, some of them also rely on API calls for rendering dynamic contents, which is the case of the DBpedia abstracts. The large amount of data requested from APIs couldn't be extracted entirely within a month today. We suggest solving this issue by a strategy composed of four steps: - a study based on the data recorded during the last abstract extraction - the test and implement the use of the TextExtracts extension and the improvement the error management - the reduction the number of possible calls - the integration into the framework of the possibility to appeal to more than one API Each step of the project will be developed into a new dedicated GitHub branch of the DBpedia extractor framework, which could be documented and used for working on the project.

Music Blocks v4 has a modular architecture with a block editor, compiler, and execution engine built separately but not yet connected. This project integrates the Masonry visual block editor into the main application, implements block snapping and connection logic so users can build structured programs, and wires the full execution pipeline (blocks to AST to IR to output) so programs produce real music and graphics. Core deliverables: (1) Masonry module integration with palette and workspace (2) snap-based block connections with visual feedback enforcing programming semantics (3) end-to-end execution connecting blocks to the Painter and Singer modules via a real function registry. Stretch goals include inline block editing and workspace zoom/pan/undo.

The AI-Powered Guiding Assistant replaces the steep learning curve of manual astrophotography guiding with a predictive, mount specific machine learning model. This project augments KStars' reactive PID controllers by utilizing an offline trained Gated Recurrent Unit (GRU) to automatically learn and counteract complex mechanical errors like gear backlash, harmonic drive signatures, and wind disturbances in real time. To ensure maximum performance on low power embedded devices like the Astroberry, the project features a native C++ inference engine built entirely from scratch using lightweight Eigen3 matrix math. This guarantees highly accurate, intelligent pulse augmentation with an absolute minimal memory footprint and without any big ML dependencies linked into the KStars ecosystem.

A VS Code (or JetBrains) extension to provide AI-powered coding assistance using Google’s Gemini API. This tool enhances the developer experience by offering smart code completions, real-time debugging help, and natural language to code conversion. It can suggest optimized code, detect errors, explain complex logic, and help developers write better, more efficient programs. The extension will also improve response times with caching mechanisms and provide a seamless UI/UX for smooth interaction. By integrating AI-driven support directly into VS Code, this project aims to boost productivity, reduce debugging time, and make coding more intuitive and accessible for developers. Here is the source code of the extension created by me, in the GitHub repository here: https://github.com/krishnaagrawal7508/GeminiBot

<p>digiKam is KDE desktop application for photos management. In digiKam, tags on photos are strongly supported for the sake of providing users with a natural workflow of searching and arranging photos in their collections. Since many of our photos contain faces, face tag has apparently emerged as an essential property for any photos management software, also with the fact that user has to tag thousand of their photos manually. Being aware of that, digiKam team has put a lot of efforts to develop face engine, capable of scanning photos and suggesting face tags automatically basing on pre-tagged photos by users. However, that functionality is currently deactivated in digiKam, as it is slow while not adequately accurate. Thus, this project aims to improve the performance and accuracy of facial recognition in digiKam by exploiting state-of-the-art neural network models in AI and machine learning.</p>

istio.io is a large application in and of itself: static content is available in three languages with multiple versions, and a large testing infrastructure acts as the end-to-end testing for the Istio project, validating that the project works as documented whenever an update is made to the docs or Istio itself. In this project, you will be mentored towards maintainership of the Istio documentation build pipeline, including completing recently started work on multi-version availability and its integration with search engines, bringing the tooling for the deployment pipeline up to date, and laying groundwork for large content changes as ambient mode moves towards the default. - Expected Outcome: - Clean builds and publishes, with no lingering warnings or errors - Updated documentation on contributing tests, such that a new user can easily contribute testable documentation - Published process for users to see old versions of the docs, where we no longer publish them on istio.io

<p>ZAP has good support for websockets, and allows them to be intercepted, changed and fuzzed. However, it doesn't currently support scanning, either passive or active, of websocket messages. Thus, it is necessary to start with an infrastructure that is going to support scans, both active and passive. The infrastructure should handle the addition and removal of plugins, providing appropriate utilities, run in a background thread, may store statistics of scanning, etc. On the other hand, a plugin implements a particular scanning method for a group of vulnerabilities. Script plugin is a special kind of plugin which is used to run scripts which are written by users and consequently processed by different scripting engines. Finally, API is useful for inter-connectivity of ZAP with other applications like ZAP HUD. I proposing a infrastructure which is going to support active and passive scanning. In addition, I am proposing feature which in my way of thinking is essential and plugins which are testing the most critical vulnerabilities.</p>

<p><strong>Thread Scheduling in HPX</strong><br> HPX currently supports seven types of schedulers:</p> <ul> <li>Priority Local Scheduling </li> <li>Static Priority Scheduling </li> <li>Local Scheduling </li> <li>Static Scheduling </li> <li>Priority ABP Scheduling </li> <li>Hierarchy Scheduling </li> <li>Periodic Priority Scheduling </li> </ul> <p>All of these schedulers are currently statically linked and must be specified at compile-time. The aim of the project is to make these dynamically loaded instead. These will be converted to the plugin system already present in HPX, which is used by message-handlers and parcelports. Factory design pattern will be followed. A scheduler-factory-base class will provide the template from which the factories of the individual schedulers are derived. These will then return scheduler-objects which can be used by executors.</p>

Dora is a powerful robotics dataflow framework, but robot behaviors require fixed YAML graphs—no natural language interface, runtime error recovery, or high-level goal decomposition. This project builds an Octos agent bridge node for Dora, enabling natural language control of a simulated UR5e robot (e.g., "pick up the red ball and place it on the green plate"). The agent decomposes commands into DOT-graph pipelines, executing via dora transport tools, interfacing with dora-moveit nodes in MuJoCo. A prototype demonstrates pick-and-place with full step completion (vs partial completion with LLM-only reasoning). Deliverables: MuJoCo simulation, Octos bridge node, agent-callable tools, DOT-graph pipeline, mock provider, test suite, documentation. Stretch: Rust-native bridge, vision-based grasping, messaging channel integration

The project’s goal is to evaluate results from checkpatch.pl, aggregate its findings and improve checkpatch.pl based on the evaluation. The checkpatch.pl script detects various coding style issues and checks for various stylistic conventions on commit messages and supporting information, e.g., consistent records of MAINTAINERS, license information, proper file permissions, etc. However, an earlier investigation on checkpatch.pl has shown that many patches in the kernel repository are accepted, even though checkpatch.pl reports findings on them. Some of those checkpatch.pl errors and warnings are “false positives”. The work in this project shall be driven by a continuous, highly iterative cycle of evaluation on large sets of commits and patches, machine-assisted aggregation and clustering to identify specific community-local conventions, and adjustment and configuration of the checkpatch.pl script. The repeated evaluation will prioritize the specific changes to checkpatch.pl.

This project enhances NiMARE’s performance and developer accessibility through a dual-phase optimization strategy. The first phase modernizes the contributor onboarding framework by updating development environment documentation and Git workflows to reflect current best practices, ensuring a lower barrier to entry for new developers. The core technical phase implements a fixed-width confidence interval stopping rule for ALE and MKDA workflows. By integrating an adaptive framework based on the Wilson Score Interval, the system dynamically prunes voxels as p-value convergence reaches statistical decisiveness. This approach significantly reduces computational overhead and execution time while maintaining Type I error control. Deliverables include an extensive benchmarking against standard 10,000-iteration runs, and—progress permitting—the expansion of NiMARE’s methodology through Signed Difference Mapping (SDM) and Publication Bias Diagnostics (Fail-safe N).

<p>The wide use of XML for document management and data exchange has created the need to query large repositories of XML data. Apache VXQuery is implemented to efficiently query such large data collections and take advantage of parallelism. The system builds upon two other open-source frameworks -- Hyracks, a parallel execution engine, and Algebricks, a language agnostic compiler toolbox. Apache VXQuery extends these two frameworks and provides an implementation of the XQuery specifics. The main idea of the project is to integrate Lucene indexing to the VXQuery system. It already has some capabilities of Lucene such as, Create a Lucene index from an XML file and execute a query by using that index. This project is to fully integrate the Lucene and extend the indexing capabilities of the system. Such as, enabling queries to dynamically select to use indexing at run time, extend indexing for HDFS folders, allow updates to collection indexes (when Adding/Deleting/Modifying XML files).</p>

<p>Building upon the work done in GSoC 2020 to make programming the PRU easier for beginners, this project aims to add tests, features, and more compatibility for simpPRU, the simple Python-like language that compiles to PRU C and runs natively on the PRU. More specifically, I am planning to add support for the BeagleBone Blue, add unit tests for every language feature, add hexadecimal support for ints, add support for modulo and bitshift operators, support for a new char/uint8 data type, support for a simple array structure, adding a more flexible for loop, and adding the ability to send more complex data in the form of strings through rpmsg and receive them in simppru-console. I will also improve the error handling in the parser and fix known issues in simpPRU. This will make the overall language more robust and complete, which will help beginners learning to use the PRU or experienced users prototyping something on the PRU.</p>

The go-mfp cpython package is a unique Go library that embeds CPython as a scripting engine, supporting multiple isolated sub-interpreters with automatic garbage collection of Python objects. As this package is planned to move into a standalone repository and potentially become critical Linux infrastructure, ensuring correctness and security across Python 3.8 through the latest version is essential. This project will build a comprehensive unit test and fuzz test suite — pairing each source file with _test.go and _fuzz_test.go files using Go's native fuzzing framework, tested across Python 3.8–latest on both x86 and ARM64. Deliverables: - Full unit test suite for all public API functions - Fuzz harnesses for sub-interpreter lifecycle, object GC, type conversions, and error handling - CI matrix builds across Python versions and architectures - Documentation for running and extending the test suite