Explore Projects

Problem: KubeStellar (KS) lacks an automated system to measure and visualize data-plane performance (e.g., sync latencies) under AI workloads, making optimization and debugging challenging. Solution: 1. Instrument KS with OpenTelemetry/Prometheus to emit sync latency/error metrics. 2. Build a pipeline (TimescaleDB + Fluentd) to collect, store, and aggregate metrics. 3. Embed Grafana dashboards into KS UI for real-time monitoring. 4. Benchmark AI workloads (e.g., distributed TensorFlow) to validate scalability. Deliverables: 1. Go-based metric instrumentation in KS core. 2. Automated aggregation service (P95, error rates). 3. Prebuilt Grafana dashboards (latency, throughput). 4. Documentation + video demo. Impact: Enables data-driven optimization of KS for large-scale AI workloads.

Kyverno has evolved significantly with the introduction of new CEL-based policy types in the v1alpha1 API version. The current documentation and website need to be updated to reflect these advancements and position Kyverno appropriately in the policy engine landscape. This project aims to enhance Kyverno's documentation, website content, and overall positioning to showcase the new capabilities while maintaining clear guidance for users transitioning from traditional policies to CEL-based formats. Expected Outcome: 1. Update and enhance Kyverno's website to reflect new CEL- based policy capabilities 2. Ensure comprehensive documentation for all new policy types 3. Update Kyverno's positioning in the policy engine ecosystem 4. Update comparison charts and feature matrices 5. Enhance user experience with better navigation and search functionality 6. Update API reference documentation with new policy types

Clad is an open source plugin to the Clang compiler that detects from the parsed Abstract syntax tree, calls to differentiate a defined function, generates code that differentiates the function using the concept of Automatic Differentiation(AD) and modifies the Abstract Syntax Tree(AST) to insert the generated code. While clad works in the frontend of the compilation process, Enzyme, another LLVM based AD plugin works in the backend, where it takes in code in LLVM IR form and then differentiates the code. This proposal aims to integrate Clad with Enzyme, and give the user the option of selecting Enzyme for Automatic Differentiation, based on his/her needs. This will give the user the same User Interface as clad for writing his/her code, but the option of using Enzyme as the backend with all its optimisations to calculate the Derivative/Gradient of the requested function. This proposal also briefly gives insights into how this can be achieved by tapping into the existing code base of Clad.

<p>Currently, appleseed only renders the surfaces of objects, and treats the space between objects as a void. Hereby, one of the most requested features in appleseed is <strong>Volume rendering</strong>. This term implies that the rendering engine takes into account how light interacts with media between the objects, and computes how it is absorbed and scattered by air, smoke or fog molecules, or by denser media such as milk or marble.</p> <p>My goal is to integrate the feature of rendering homogeneous volumes to appleseed engine, and thus making it capable to handle simple volumetric effects, such as light shafts in a foggy environment. During my work I will investigate different approaches of visualizing volumes, select the techniques that are modern, efficient and fit the best to the existing path tracing code of appleseed, and then implement the chosen methods. Additionally, I will introduce how users will interact with the newly added features by extending the user interface of appleseed.studio.</p>

<p>This project consists of two main parts of the automated generation of documentation for Siddhi Complex Event Processing Engine.</p> <ol> <li>a maven plugin for automated documentation generation for a single extension module or the siddhi core. The metadata annotated using the @Extension annotation are retrieved using the ClassIndex library which is already used by siddhi for indexing the annotated processor classes. Afterwards, documentation is generated using the metadata using a template engine.</li> <li>Creating an index of the Siddhi Extension Repositories.</li> <li>Adding and committing the <code>docs/</code> directory content and the <code>mkdocs.yml</code> file to Git. Pushing the changes in the <code>docs/</code> directory content and the <code>mkdocs.yml</code> file to <code>origin master</code>. Automatically deploying documentation in each new release of Siddhi.</li> </ol>

To address the challenges identified with the FOSSology scheduler, particularly the limitations stemming from its programming language (C) and its linear queue design, proposed idea is to refactor current scheduler codebase in python and integrating Rocketry to create a more flexible, maintainable, and feature-rich scheduler. 1. Task Scheduling: Implement task scheduling with rocketry, utilizing its cron-style syntax for defining job frequencies. This allows for precise control over when jobs are executed, aligning with FOSSology's existing scheduling requirements. 2. Mutual Exclusivity and Concurrency: Define tasks with mutual exclusivity constraints directly within Rocketry, ensuring that jobs which should not run concurrently are handled appropriately. Utilize Rocketry's support for asynchronous execution to improve the scheduler's efficiency and responsiveness. 3. Error Handling and Logging: Built-in error handling and logging mechanisms to ensure that job failures are captured accurately, and relevant information is logged for debugging purposes.

Improve how cilium.io content is discovered, ranked, and reused by search engines and AI tools. This includes enhancing technical SEO, optimizing for answer engines like Google SGE and Perplexity (AEO), and structuring content to be easily cited and used by large language models (AIO). The mentee will perform audits, recommend improvements, and implement changes across meta tags, structured data, documentation formatting, and content strategy. Expected Outcome: SEO, AEO, and AIO audit report for cilium.io, Implementation of structured metadata (e.g., FAQ schema, article metadata, canonical URLs), TL;DR summaries or answer-first formatting added to key documentation and product pages, Deep-linked, self-contained concept pages created or refactored for LLM usability, Improved search visibility and AI result representation (tracked via baseline comparison)

The aim of this project is to enhance the Beam Yaml API by introducing ML and IO transforms to provide the users with more functionalities. The suggested set of transforms to be implemented are: 1. RunInference 2. ReadFromSpanner 3. WriteToSpanner 4. Enrichment Transforms I also want to add three use cases for the Yaml API, providing end-to-end pipelines demonstrating the use of the newly implemented transforms. The suggested use cases are: 1. Text processing with MLTransform and RunInference 2. Processing tabular data from Spanner 3. Enriching tabular customer data with Enrichment Transform. By expanding the capabilities of the Yaml API, the goal is to streamline the process of constructing and managing data pipelines using Apache Beam. This improvement will enable users to tackle a wider array of data processing tasks with greater ease and efficiency, potentially attracting a broader audience to leverage Apache Beam for their data processing needs.

JSON Schema Studio visualizes JSON Schemas as interactive graphs, helping developers understand complex structures. While the current version works well, there are areas where rendering correctness and user experience can be improved. This project focuses on ensuring correct dependency-based rendering (especially for $defs), improving graph navigation, and enhancing synchronization between the editor and visualization. It will also address issues like edge collisions and unstable rendering during live edits. Additionally, features like validation error navigation, file upload, and visualization export will be introduced to improve usability. The final deliverables include: - Dependency-aware rendering using topological sorting - Improved graph interaction and navigation - Validation error navigation in the editor - Reduced edge collisions - Stable rendering during live edits - File upload and export support These improvements will make the tool more accurate, interactive, and useful for developers.

Music Blocks v4 is a visual programming environment that lets learners explore programming concepts through music. Students use lego-like “bricks” to compose melodies, rhythms, and logical structures — making coding more approachable and creative. As part of GSoC, I developed the Masonry Module, a new system for how these bricks are generated and used. My work introduced a scalable block engine with detailed model-view architecture, a categorized palette, smooth drag-and-drop interactions, disconnection logic, and collision detection system to help users build programs. I also worked on connecting the visual bricks to Music Blocks underlying execution engine using the ASTs, so what students build visually can be run as code. This makes the environment both more intuitive for learners and more maintainable for developers. The Masonry Module now serves as a strong foundation for future features in Music Blocks v4, like macros, advanced animations, and performance optimizations.

<h3>Adaptive Quantization based on an activity mask.</h3> <p>The human eye is more tolerant towards errors in areas of high activity and is quick to find out errors in areas of lower activity. To leverage this psychovisual characteristic, quantization can be made adaptive based on the activity mask. Activity masking will be implemented in two phases:</p> <ol> <li>Biasing the RDO based on the activity at a specific region.</li> <li>Varying the quantizer offsets across segments based on activity.</li> </ol> <h3>Optimizing the quantization algorithm using Trellis Quantization:</h3> <p>Using Trellis Quantization passing the activity measurements as the weights to the trellis. The output of this Activity masked Trellis is used for quantization. This helps the quantization perform better in PSNR metrics while increasing perceptual image quality significantly. This is a feature that has proved to perform better in the case of x264 and is expected to yield similar results at rav1e too.</p>

<p>The relevance of ARM processors is rising. Especially since ARM recently started targeting the servers and desktop market, thus going beyond the mobile devices. That’s why malware targeting ARM is becoming an even bigger threat every day. On the other hand, it is still the x86 architecture for which most reverse engineering tools are developed. This Google Summer of Code (GSoC) project aims to add ARM support for both the dynamic analysis framework DRAKVUF and the virtual machine introspection (VMI) library libvmi. The idea is to base our project upon the result of an earlier GSoC project which added altp2m support for Xen on ARM. The altp2m subsystem defines different views on the guest’s physical memory and allows to dynamically switch among them. With altp2m and DRAKVUF we are able to build a stealthy VMI framework. In summary, the goal of the GSoC project is to add support for DRAKVUF for ARM and thus provide more options for reverse engineering on the ARM architecture.</p>

<p>The proposal at hand describes the working plan for developing a graph-based SLAM algorithm using the mrpt toolkit in the following summer. The suggested strategy builds upon the ideas developed by (Olson, 2009) for the data association and robust loop closing parts, while using already implemented schemes (mrpt version of Levenberg Marquardt, iSAM solver) for dealing with the optimization part. The result by the end of summer should be a fully functional, robust and usuable graph-based SLAM algorithm ready to be used by researchers and roboticists. We provide an overal timeline, with intermediate milestones to make sure that we meet the goals of the project. The proposal begins with an introduction to the graph-based formulation and lists already implemented and successful graphSLAM strategies. The following two sections (implementation details, timeline) describe the graphSLAM algorithm that we suggest. The final section provides with general information about the author and his background in simultaneous localization and mapping and open-source programming projects</p>

<p>GSoc 2015 brought structured light to OpenCV and I would love to extend the module this year. Among all the available algorithms, phase-shifting profilometry (PSP) is one of the most popular and I believe OpenCV would benefit from its implementation. Unfortunately, PSP does not perform well on dynamic scenes since it belongs to time-multiplexing methods. Indeed, successive patterns are not deformed in the same way which leads to reconstruction errors. To reduce reconstruction errors due to motion, scientists had the idea to combine PSP with Fourier transform profilometry (FTP), a one-shot method that uses the same patterns. My goal for GSoC 2016 is to add PSP, FTP and Fourier assisted phase-shifting profilometry (FAPS) to OpenCV. Spatial phase unwrapping, which is essential to PSP, FTP and FAPS, will be coded as an independent module due to its broad number of applications. Finally, as a proof of concept of scene understanding from structured light, an automatic piecewise-planar surfaces detection will be tested on the results provided by Fourier transform profilometry.</p>

<p>Dynamic languages trade some of the compile-time safety properties of statically typed languages for greater flexibility for a programmer to write correct programs that a static compiler would turn down as potentially faulty. There is a recent trend to integrate aspects of both disciplines, commonly by "adding types" to languages originally designed as dynamic.</p> <p>There has been interest in the Ruby community to explore such an approach: Yukihiro Matsumoto devoted his keynote at RubyConf 2014 to the potential implementation of static typing in the language. The topic is complex: a Ruby tightly corseted by types would not be true to the essence of the language.</p> <p>Under a gradual typing discipline, type annotations can be specified at will: interesting parts of the program can be given explicit types and their type safety checked statically. We propose an implementation of gradual typing in Matz's Ruby Interpreter, drawing inspiration from similar additions to other dynamic languages, with strictly optional type annotations consistent with Ruby's DRY and "lazy" philosophy and an evaluation of the practical usefulness of gradual typing.</p>

The zlib is required for compiling and running many existing C / C++ / Rust apps in Wasm. Most noticeably, it is [needed in the Python port to Wasm](https://github.com/python/cpython/issues/93819). The VMWare Wasm Labs team is using a zlib port from [Singlestore](https://github.com/singlestore-labs/python-wasi) in [their Python Wasm runtime](https://wasmlabs.dev/articles/python-wasm32-wasi/). In WasmEdge, we could support the zlib host functions through our [plugin system](https://wasmedge.org/book/en/plugin.html). This way, any existing zlib apps can be compiled to Wasm and runs inside WasmEdge. - Expected outcome: Create a new [WasmEdge plugin](https://wasmedge.org/book/en/plugin.html) that exports all public functions in `zlib`. Implement SDK (in C/Rust) that uses the C ABI to generate corresponding headers for the above plugin. Generate the unit tests and pass the unit tests. >80% of code coverage for verification.

This project aims to evolve the BLT-Vanish existing privacy management platform into a proactive, real-time identity defense system. While the current platform is effective at privacy management, it lacks the live features necessary to combat modern threats, such as AI-driven phishing detection, automated credential hygiene, and a unified way to correlate suspicious logins. To solve this, I plan to introduce the Universal Identity Shield, built on a hybrid local-first and edge-processing architecture. This system will provide low-latency, explainable risk scoring and actionable guidance through three key phases: developing a foundational risk engine, implementing core security workflows like dark web monitoring and guided password rotation, and hardening the production environment using Flutter and Python-based Cloudflare Workers. The project will ultimately deliver a comprehensive suite of tools, including a phishing detection engine, a zero-plaintext encrypted vault, and an anomaly correlation system, all backed by full documentation and handover materials.

<p>Multi-Class Classification is a central task in data mining there are a variety of classifiers that compute scores of the samples to belong to the classes. The aim is to deliver a product that will be used to analyse the classification algorithms, find sources of classification errors and reducing errors using available data features. This involves evaluating performance of classifiers using Interactive Visualizations and providing the users with useful and reproducible information about classification Data. Back-end plugins for WEKA, RapidMiner, KNIME and R to acquire and export classification data to front-end that produce visualizations using web technologies (D3.js) in form of stacked bar charts and confusion matrix, which will easy, intuitive and high quality implementation to interactively select certain samples in the visualization for further investigation and detailed feature analysis run in default browser to provide platform independent functionality. A guide and documentation for all the code for easy installation, usage, interpretation of results and further extension of project related to this tool in the form of a web-page will be a part of this project.</p>

Numba is a JIT compiler that translates a subset of Python and NumPy code into fast machine code. Cppyy is an automatic, run-time, Python-C++ bindings generator, for calling C++ from Python and Python from C++. Cppyy has to pay a time penalty each time it needs to switch between languages which can multiply into large slowdowns when using loops with cppyy objects. This is where Numba can help. Since Numba compiles the code in loops into machine code it only has to cross the language barrier once and the loops thus run faster. Initial support for Cppyy objects in Numba enabled the use of builtin types and classes, but some essential C++ features, such as references and STL classes, are not yet supported. The project aims to add support for C++ reference types in Numba through Cppyy and improve the existing numba extension implementation to provide general support for C++ templates. This added support will allow cppyy users to define a wider array of standard and templated functions that can leverage reference types to the C++ code defined in python.

The goal of this project is to enhance Apothesis, an open-source software that enables the simulation of thin film deposition processes, by adding new lattice structures to its capabilities. Thin film deposition is an essential step in the manufacturing of numerous products and devices, including solid-state and medical devices, and computational simulation is a valuable tool for scientists and engineers in this field. In the previous GSoC, the student worked on the I/O operations of Apothesis and designed the necessary infrastructure to enhance the software. In this project, the objective is to expand the capabilities of Apothesis by adding hexagonal and diamond lattices to enable the simulation of more complex materials and processes. The addition of these new lattice structures will allow Apothesis to simulate a wider range of materials and enable the development of new technologies that can streamline or enhance thin film deposition processes. The project will involve researching the hexagonal and diamond lattice structures, developing the necessary code, and testing the implementation. The end result will be a more robust and versatile software tool for scientists and engineers working in thin film deposition processes.

<p><strong>goodbot</strong> is a help-chatbot intended for helping out new applicants of Wikimedia Outreach programs. The bot is designed to be accurate, modular, intelligent and most importantly, simple. The primary functioning of a help(chat)bot is to assist people and goodbot does that via simple, succinct help messages to lead its users to the right place, whether that be the GSoC 2020 instructions or Outreachy Round 21 project ideas, goodbot intends to do its job perfectly, all the time - and all of that is achieved with the help of the Zulip real-time API.</p> <p>Zulip's real-time API is intended as a catch-all method to allow functioning of external integrations without using higher-level APIs, this will allow our bot to remain active all the time, listening in on each message and enabling it to activate anytime at our cue (such as "help me", or even "search what is the best way to write an abstract") instead of being limited to Zulip-provided webhooks and configuration limitations such as supervisord and zulip-botserver.</p> <p><strong>goodbot</strong> is always-on and ready to assist you and all it needs is an opportunity.</p>

While working with real-time systems, I observed that Flutter DevTools provides detailed visibility for HTTP requests but lacks support for persistent protocols like WebSockets. Once a connection is established, developers have little to no insight into message flow, latency, or connection lifecycle, making debugging significantly harder. This project aims to address that gap by extending the Dart SDK (dart:io, dart:developer, and the VM Service) to capture WebSocket frame-level and connection-level data. This data will then be integrated into the DevTools Network panel, following the existing HTTP profiling model to ensure consistency and minimal overhead. The implementation will include WebSocket instrumentation in dart:io, exposure of profiling data via the VM Service, and UI integration in DevTools to display messages, sizes, latency, and lifecycle events. If time permits, the same architecture will be extended to support gRPC traffic. By the end of the project, developers will be able to inspect WebSocket communication in DevTools with the same clarity and usability as HTTP, significantly improving debugging for real-time applications.

<p>ArviZ is a Python package for exploratory analysis of Bayesian models, from diagnostics to visualization. It is designed as a backend-agnostic tool with the goal to reach the widest user base and thus contribute to extend best practices among Bayesian inference practitioners.</p> <p>Two key problems in this field are model comparison and convergence analysis. Model comparison is not trivial because of the different structures and number of parameters of each model. Fortunately, there are some information criteria (i.e. leave-one-out cross-validation) that can be used for this task. Even though convergence is proven for infinite iterations, it is not the case for finite MCMC runs, which can be arbitrarily bad. Convergence assessment must take into account both intra- and inter-chain correlations.</p> <p>ArviZ implements many of these algorithms for diagnostic and comparison, at least at a preliminary level, but it still lacks plots and tools to ease and improve its interpretation. This project seeks to design and implement these tools. Moreover, it will pay special attention to testing and documentation with examples not only of the new functionalities, but also of the already implemented ones.</p>