Explore Projects

<p>As part of the project, I intend to develop a message queue based system pluggable to the Mailman core archiving interface(IArchiver) which will enable reliable, asynchronous and multi-client archiving. This will also lead to a more robust distributed architecture while also expanding the scope of Mailman server allowing it to hook it up to a wide variety of web applications like static web page generators, event trackers or websockets servers.</p>

This project aims to improve the interpretation of non-linear dimension reduction (NLDR) methods like t-SNE and UMAP by linking them with linear dimension reduction, for example using a grand tour. I will develop an interactive Shiny app and R package that integrates NLDR methods with the detourr package, allowing users to explore and diagnose NLDR views through linked brushing and dynamic tour displays. The app will support advanced diagnostics including slice and sage tours, and integrate quollr visualizations. The final deliverable will be a CRAN-ready tool for reliable, scalable exploration of high-dimensional data.

Metagenomic assembly is essential for understanding microbial communities, but existing tools often struggle with fragmented genomes, misclassified errors, and scalability issues. My goal is to develop a distributed algorithm for error correction and assembly, making it easier to process large and complex metagenomic datasets efficiently. To achieve this, I plan to use distributed computing frameworks like Dask to improve scalability, ensuring that even terabyte-scale datasets can be handled smoothly. I also aim to design better error correction techniques to preserve low-abundance species and improve assembly accuracy. Additionally, I want to explore GPU acceleration and machine learning to refine error detection and optimize processing times. At the core of my approach is a distributed de Bruijn graph assembly algorithm that constructs graphs from k-mers while clustering and annotating nodes based on coverage, GC content, and paired-end data. Unlike existing tools like Velvet (designed for single-genome assembly) and MetaVelvet (for metagenomic assembly), my method will efficiently break down graphs into species-specific subgraphs, reducing errors and improving the quality of the final assemblies. This will lead to better contig generation, taxonomic classification, and error correction, while also ensuring the method scales well for large datasets. Deliverables: 1. A distributed error correction module that improves accuracy while retaining biologically important data. 2. An optimized assembly pipeline to generate high-quality contigs and scaffolds for taxonomic and functional analysis. 3. A novel species-aware de Bruijn graph decomposition to improve metagenomic assembly and reduce errors. 4. Scalability improvements to ensure smooth performance across HPC clusters and cloud platforms. 5. AI/ML enhancements to improve error correction and sequencing accuracy. 6. Comprehensive documentation and testing to make the tool easy to use and reproducible.

The project aims to create a Kotlin Multiplatform Library version of Flogger, which is a popular logging library for Java. The new library will work on multiple platforms including JVM/Android, Kotlin/Native (iOS), and Kotlin/JS. The goal is to provide a commonly-needed logging tool that works across various platforms, making it easier for developers to write better and more readable logging code. The project will involve designing and delivering a Kotlin Multiplatform library, with a greater priority on JVM/Android and Kotlin/Native (iOS) than other targets. Additionally, the project includes implementing integration with Logcat on Android, providing readable documentation with examples on how to use the library, and publishing the library on Maven Central.

This GSoC 2024 Kotlin project proposal aims to enable kotlinx-benchmark support for the Android platform. The project will enhance the kotlinx-benchmark library to detect and adapt to the Android runtime environment, enable existing kotlinx.benchmark functionality to run on the android platform, and allow customisation of benchmark configurations via annotations or in build.gradle. The main deliverables include an updated version of the kotlinx-benchmark library for Android, sample code, updated README documentation, and tutorials for using it on the android platform.

This proposal focuses on enhancing the kotlinx-benchmark library API and user experience, fostering community growth and collaboration in Kotlin multiplatform development. The kotlinx-benchmark library is an open-source solution for benchmarking Kotlin code across multiple platforms. Although it provides a foundational structure, it currently lacks several essential quality-of-life features that would streamline its usage. This project aims to address these limitations by introducing fine-grained benchmark configuration options, ensuring feature parity between JVM and Kotlin/Native benchmarking, developing a command-line API, and integrating modern Gradle support. Furthermore, the project will enhance the library's documentation, integration tests, and examples to provide a comprehensive user experience. The anticipated outcomes of this project encompass: - Comprehensive documentation with practical usage examples - A user-friendly API that simplifies the benchmarking process - Versatile options for benchmarking Kotlin/JVM code across various platforms To successfully execute this project, proficiency in Kotlin and an understanding of Gradle internals are essential. By undertaking this project for Google Summer of Code, I aim to contribute significantly to the Kotlin ecosystem and promote a thriving open-source community centered around multiplatform development.

The migration to Maven Central's new API instance has introduced significant changes, requiring specialized support in Gradle plugins for seamless publishing. This project aims to develop a new Gradle plugin compatible with the updated APIs, simplifying the process with Kotlin DSL extensions and automating tasks like GPG signing and artifact packaging. Deliverables include a fully functional plugin, comprehensive documentation, and robust test coverage.

The IntelliJ Platform Gradle Plugin, the official Gradle plugin for building, testing, verifying, configuring environments, and publishing plugins for IntelliJ IDEs, includes a VerifyPluginTask that verifies a plugin against one or multiple IDEs. Currently, reporting is managed by the Verifier CLI, which employs its custom reporting system to generate verification reports; however, the VerifyPluginTask could benefit from Gradle's Reporting API for more configurable reports. Additionally, integrating Gradle's Worker API for parallel execution of the verifyPlugin task could enhance the IDE plugin development experience. The goal of this project is to assess the benefits and ultimately implement the necessary changes to the verifyPlugin task. Lastly, explore further optimizations to enhance the plugin development workflow.

This project enhanced Gradle Build Server for Android development by implementing composite build support, improving Java Home handling, and providing support for Android Java projects. These enhancements significantly improve the development experience for Android developers using Text Editors/IDEs that utilize the Build Server Protocol (BSP). By bridging the gap between Android Studio and Gradle Build Server, this project contributes to a more productive development workflow. This is a start to let developers benefit from the powerful capabilities of Android Studio within their preferred development environments.

This project focuses on enhancing Gradle’s Configuration Cache compatibility across widely used Gradle plugins. Configuration Cache is a performance feature that allows Gradle to reuse the results of the configuration phase between builds, significantly reducing build times. However, many plugins are not fully compatible with it due to issues such as accessing project APIs at execution time or relying on non-cacheable inputs. The project aims to identify gaps by analyzing popular plugins such as Nebula and Liquibase to detect incompatibilities with Configuration Cache, then fix these issues by refactoring plugin code to eliminate non-cacheable operations and ensure tasks only rely on properly declared inputs and outputs while avoiding illegal access during execution. In addition, configuration cache tests will be introduced to validate cache correctness and guarantee future compatibility, ultimately resulting in faster and more reliable builds for developers.

Kotlin is one of the most widely used languages in modern software development, but there is no structured, global picture of how it is actually being taught. Students graduate without knowing coroutines. Courses skip Jetpack Compose. Academic syllabi lag years behind what the industry expects. This project exists to measure that gap and help close it. I will collect and analyze data from 80+ university curricula across 6 regions, online course platforms including Udemy, Coursera, and JetBrains Academy, surveys of 150+ students, educators, and developers, and 500+ public GitHub repositories comparing educational and real-world Kotlin code. Using Python, SQL, and Tableau, I will identify where the gaps are largest, what is driving them, and what can be done about it. The deliverables are: a curated open dataset of Kotlin educational resources, an interactive dashboard for the community to explore trends by region and topic, and a comprehensive "Kotlin in Education" report with concrete recommendations for the Kotlin Foundation and educators worldwide.

This project aims to modernize Jenkins plugin development using Gradle by updating the existing Gradle JPI plugin and introducing a new convention plugin. The primary goal is to achieve feature parity with Maven workflows, improve compliance with Jenkins hosting requirements, and enhance developer experience. Key deliverables include migrating the codebase from Groovy to Kotlin DSL, integrating Jenkins-specific tools like Plugin Compatibility Tester (PCT) and Bill of Materials (BOM), and simplifying build, test, and release processes for Jenkins plugins. This initiative will strengthen the Gradle ecosystem while improving the reliability and efficiency of Jenkins plugins.

This project aims to address the challenge of testing and ensuring consistency across @Composable components in Compose Multiplatform projects. The proposed solution is to develop a Compose Multiplatform component gallery generator that allows developers to design and verify comprehensive component systems within their applications. The deliverables for this project will include: 1. A Gradle plugin: The main purpose of this Gradle plugin is to generate a runnable app showcasing the Story components written by the developer, tailored for their target platform. This plugin will facilitate the automatic generation of user interfaces for testing components. 2. A Runtime Library: The Runtime Library enables developers to define the specifications of the @Composable components they want to test. This will include an annotation system to mark components as Story items, with the ability to specify component properties and target platforms. In practice, developers can integrate this tool into their project structure, which will encompass common and platform-specific modules such as commonMain, androidMain, and desktopMain etc... our Gradle tasks will offer a streamlined process to create an app per platform to display all Story components.

This project aims to address the challenge of creating a seamless and efficient integration between Gemini and Vertex AI in Firebase for Android and iOS platforms using Kotlin Multiplatform (KMP). The proposed solution is to develop an open-source KMP library that will support Gemini with Vertex AI in Firebase, focusing on best practices for creating KMP libraries and ensuring robust production implementation across both Android and iOS platforms. The deliverables for this project will include: 1. Kotlin Multiplatform Library: This library will provide seamless integration between Gemini and Vertex AI in Firebase, supporting Android and iOS. 2. Sample Code and Documentation: Along with the library, sample code and thorough documentation will be provided to assist developers in utilizing the library effectively for their own projects. In practice, developers can integrate this library into their Kotlin Multiplatform applications. Our library will offer a seamless process of integrating Vertex AI into Firebase apps for both iOS and Android.

This project aims to integrate the torch.compile function released in PyTorch 2.0 into DeepChem's PyTorch models, unlocking significant performance improvements for training and inference. By leveraging advanced JIT compilation techniques used in torch.compile, this project will enable DeepChem users to optimize their models for faster execution without requiring code modifications. Initial benchmarks demonstrate promising speedups for various architectures, and further testing will be conducted to ensure broad compatibility and optimal performance gains across DeepChem's diverse model library. This project will ultimately empower researchers and developers with faster and more efficient tools for scientific discovery and innovation.

Open Climate Fix’s Quartz Solar forecasting model uses a simple rule-based "adjuster" that averages recent forecast errors to correct incoming solar forecasts. While effective in stable conditions, this method is rigid and might be suboptimal under rapid weather transitions or atypical error patterns. This project aims to compare this rule-based logic with TabPFN, a transformer model for tabular data. It seeks to evaluate whether TabPFN or its time-series variant, TabPFN-TS, can predict adjustments based on features such as time, forecast horizon, recent errors, and more. Through experiments, one key goal is also to determine whether TabPFN improves forecast skill—specifically the P50 quantile forecast—over the current approach, and whether it is efficient enough for deployment.

The spinebil package provides diagnostic tools to evaluate projection pursuit (PP) index functions, which are used to discover informative low-dimensional projections of high-dimensional data. However, current tools for understanding the behavior of these indices under varying data conditions are limited. This project aims to enhance spinebil by developing diagnostics that assess how PP indices behave under noise, structure, varying sample sizes, and scale interpretation. I will implement routines to test index performance across noise-to-structure transitions, evaluate index value ranges, analyze sample size sensitivity, and apply these diagnostics to both existing and scagnostic-based indices (e.g., stringy, skinny). I will also optimize the code for performance and clarity, write detailed documentation and a vignette, and design a hex sticker for the package to support its identity on CRAN. This project will support the development of more robust, interpretable projection pursuit indices and make spinebil more accessible to researchers, educators, and developers.

This project improves CloudMonkey CLI autocompletion by addressing a key limitation where enum-type parameters (such as protocol, state, and intervaltype) do not provide any value suggestions due to the absence of corresponding list APIs. While existing completion works well for commands, parameter names, and boolean values, enum parameters currently result in no suggestions, reducing usability. To solve this, the project introduces a structured allowedValues field in CloudStack’s API discovery layer, making valid parameter values machine-readable and accessible via listApis. CloudMonkey will be enhanced to consume this metadata and provide direct value suggestions, along with improvements to entity-reference completion using existing related API mappings. The deliverables include extending the CloudStack API framework, implementing enum-aware autocompletion in CloudMonkey, annotating high-impact parameters, improving entity completion reliability, and adding supporting tests and documentation. This ensures a backward-compatible, user-friendly enhancement to CLI interaction without changing existing APIs.

The goal of this project is to develop a dynamic detection of error conditions from openQA test results, which will help operating system developers benefit from similar test failures. In order to implement this requirement, I firstly designed a detailed procedure, including four stages, to ensure practicability and gradually improve the performance. Firstly, I will use fuzzy search and basic machine learning to obtain basic results. Then, ensemble learning is used for a better result. Next, I will use these results to label failure messages. The final stage is to build a two-tower model and employ a pre-trained model for the best detection results. I will also develop the web page for availability of this new function.

<p>This project aims at improving the workflow for managing streams by improving their editing UI, adding more permission sets, refactor existing permissions to make it is easy for both users and administrators to handle subscriptions for streams more easily by finishing long-pending features like Default Stream Groups.</p> <p>As stream settings and left sidebar is closely affected by any change in either of them so a parallel aim would be to improve Zulip's left-sidebar according to changed stream settings features and also to add new features to it so that it becomes more interactive rather than just listing streams/topics/PMs.</p> <p>I also aim to improve the performance of web app for narrowing to different message views, by fixing various high priority issues that are related to the message view area. Along with performance-related issues in message viewing I aim to solve issues related to interleaved views in Private message views by utilizing recent topics UI for this and improving image previewing support for messages.</p>

This project aims to implement high-priority features in the Zulip server and web application, focusing on message editing and settings. In message editing, the project aims to add support for moving messages by recency, improve permission checks by hiding specific message move options when not allowed, refine how message move history is displayed, and enable deleting items from a message’s edit history. In settings, the project aims to introduce group-based, per-channel permissions for those who can create and edit topics to give organizations better control over channel permissions.

<p>Elm's de-facto standard source code formatter, <em>elm-format</em> is based on Elm's 0.15 compiler parsing code. Since Elm 0.19 the compilers parsing code has been rewritten to eliminate the dependency on <a href="https://wiki.haskell.org/Parsec" target="_blank">parsec</a> and <a href="https://hackage.haskell.org/package/indents" target="_blank">indents</a> for parsing and to greatly improve performance. <em>elm-format</em> has however diverged from the compiler to the point where integrating this rewrite is nontrivial. The end goal of this project is to integrate the performance improvements from the 0.19 compiler into elm-format.</p>

The objective of this project is to develop an application that connects to a Liquid Galaxy installation. The application will be developed using Dart/Flutter and will be structured into two main components: a backend and a frontend. The CHE project offers a visual and interactive experience that allows users to explore different historical sites in a city or a country. In my case, the project is focused on the city of Lleida. The CHE project is developed on the Liquid Galaxy platform, where Google Earth is displayed continuously and synchronously creating a unified panoramic view. On top of this visualization, KML files are integrated to display information about the different historical places in the city, allowing users to easily locate and explore them in a simple and intuitive way.