Explore Projects

<p>This project proposes the development of a module that uses Machine Learning to classify correctly the audio-based relative data which is extracted from music tracks. Python’s related Machine Learning (ML) library, scikit-learn, is used for the training of the data and the predictions of the classification results.</p> <p>This work replaces/reproduces the existing ML classification problem procedure that follows the gaia library with a new ML model infrastructure that uses the Python library, scikit-learn. This new infrastructure is built in high-level modeling, it reproduces classification process with the SVM model, and can be easily extended with other Machine Learning and Deep learning models that can be then compared between each other or even combined.</p>

<p>Toil is an open-source Python workflow engine that lets people write data analysis pipelines in Python, CWL, and WDL. Toil has support for common workflow language (CWL), an open standard for describing analysis workflows. The power of Toil was demonstrated in “Toil enables reproducible, open source, big biomedical data analyses” paper published in Nature Biotechnology volume where it is described how well it scaled for a dataset of 108 terabytes on 32,000 cores on a public cloud.</p> <p>This project aims to implement data streaming to speed up the analysis by avoiding slow disk/storage IO and speeding up the start of tool execution when it isn't required to wait for data to download. The main focus is to implement this first in AWS S3.</p>

The goal of this proposal is to address the issue of how difficult it can be to package and reuse computational workflows and analyses in genomics and health research since diverse data and workflow standards don't always work together seamlessly. By creating a Python library and related command-line tool that enable bidirectional conversion between RO-Crates (with pertinent computational workload profiles) and GA4GH WES/TES payloads, the RO-GA4GH Bridge project seeks to address this issue.

Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.

<p>In real life projects it is not uncommon that the whole test suite takes hours to execute completely. This makes it hard to follow the good practices to execute the complete test suite for each commit. Providing early negative feedback (fail the tests as early as possible) could streamline the developer work. In order to solve the problem it would be better to reorder the tests so most relevant test are executed first so they have the chance to fail early. “Most relevant” could mean : dependant on recently changed code, recently failing or most frequently failing tests.</p>

<p>antiSMASH, a python-based tool to mine micro-organisms genomes, currently uses pyQuery to generate static HTML pages. Consequently, several difficulties are found when improvements/changes need to be performed. This library is commonly described as too verbose, implying most of the times, string concatenations and mixed code for both presentation and logic. Subsequently, it is not much intuitive. In addition, recent patch update from 1.2.9 to 1.2.10 resulted in a backward compatibility break, and as a minor patch should not raise compatibility issues, the trust in this library is somehow compromised. Template Engines overcome the majority of the issues related to output generation. They are powerful tools that allow the developers to speed up their work in an easier and much cleaner way.</p> <p>This project proposes moving antiSMASH to jinja2, a well known, widely used and developer-friendly templating language for Python. With this migration, we intend to facilitate the future development of antiSMASH as well as the onboarding of new developers to the team. Moreover, considering jinja2 enormous user-base and applications, a backwards compatibility break in a minor version is unlikely.</p>

Sugar Labs has more than 250 activities GitHub and elsewhere which have scope for improvement. Since the support for Python2 was withdrawn from Python Foundation, porting the activities to Python3 and GTK+ 3 is very crucial. My work on this project includes, (1) Porting activities to GTK+ 3 and Python3. (2) Implementing basic game design features which attracts the elementary grade children (activities from Honey). (3) Adding activity specific features like collaborations and enhance User Interface & User Experience. (4) Testing and modifying the activities to ensure 12 activities are ready to release.

The Problem: Sugar currently relies on GTK3, which is nearing end-of-life and doesn’t support Wayland properly. This makes it harder to run on modern Linux systems. The Solution: This project focuses on migrating the core "Fructose" activities (Calculate, Log, Chat, Browse, Read, Terminal, etc.) from GTK3 to GTK4. This isn’t just a direct API update — many parts of the UI depend on older X11-based patterns that need to be reworked. I’ll update layouts to Gtk.Box/Gtk.Grid, move input handling to GTK4 event controllers (like Gtk.GestureClick), and migrate system integrations to newer GTK4-compatible libraries such as WebKitGTK 6.0, VTE 3.91, and Evince 4.0. For more complex rendering (like TurtleArt), I plan to use a Cairo bridge with Gtk.Snapshot.append_cairo() instead of rewriting everything from scratch. Deliverables: A working GTK4 port of the supported Fructose activities that runs properly on Wayland. Since the Sugar shell is still evolving, I’ll validate everything locally using my standalone main.py wrapper before integration.

This project will develop the core execution engine for Music Blocks 4, an educational platform that helps students explore music, mathematics, and programming through block-based coding. The Program Engine will allow users to create musical programs by arranging visual blocks and then execute these programs to generate music with precise timing. I will implement a robust Abstract Syntax Tree (AST) representation of programs, an interpreter that executes block instructions, a state manager to track variables and program state, and a scheduler for time-based musical operations. Key deliverables include a complete execution system for basic programming constructs, music generation capabilities, concurrent execution for multi-part compositions, and comprehensive error handling to provide clear feedback to users. The end result will be a performant, reliable foundation that enables Music Blocks users to create, share, and learn through interactive musical programming, with special attention to educational use cases and accessibility.

The goal of this project is to develop an HR management module for the CARE system, streamlining employee management and automating leave and holiday tracking. The platform enables HR to efficiently manage employee records, process leave requests, securely handle document uploads, manage holidays, and allows employees to apply for leave and access their profiles and leave history.

The aim of this project is to make it easier to use MaveDB datasets for clinical use, as most of the MaveDB datasets are not annotated in a way that allows them to be combined with other genomic data. Datasets in MaveDB will be mapped to the human genome using the GA4GH Variant Representation Specification (VRS). This can be achieved by mapping sequences using alignment algorithms, transforming the results into VRS objects, and validating the results.

Accessing medical data through the care web app can be daunting for patients in rural or remote areas who often face challenges with digital literacy, internet connectivity or lack of access to computers. Currently, retrieving appointments, health records etc requires users to log in and navigate the care web app, which makes it difficult for those with limited digital exposure to access their essential medical information. This project introduces an Instant Messaging wrapper for the care EMR, built as a django plugin. Which allows patients and staff to securely fetch medical records, check appointments etc and receive alerts and notifications through familiar, easy to use messaging apps like WhatsApp. To ensure HIPAA security compliance, the system uses a 2 step authentication process which includes (1). matching phone number and (2). verifying requestor's date of birth. It will also include redis based caching, ratelimiting of requests to prevent abuse and async task management via celery to handle sending of notifications in the background. A frontend plugin will also be developed to give staff the ability to easily send alerts and notifications and allow patients to download PDFs, such as medications and lab reports. Deliverables: 1. A functional, django based backend plugin, capable of securely serving patient and staff queries via various instant messaging providers. 2. A frontend developed using care_hello_fe to manage notifications and handle PDF downloads. 3. Proper tests utilizing pytest and Playwright for both the backend and frontend. 4. Complete and comprehensive documentation using sphinx and swagger, along with setup guides and demo videos. 5. Production ready deployments of both the backend and frontend plugins integrated within care.

<p>The project aims to create a platform for hosting and sharing Vega and Vega-Lite visualizations. It will facilitate a user to save, fork and publish any visualization on the web. It is designed keeping in mind the user-benefits and covers everything from back-end to front-end with few new features. It will be integrated into the editor itself so that the user can conveniently make and share the visualization from the same place. This lowers the barrier to entry into the vega ecosystem.</p>

<p>PathwayMapper provides a pathway visualization environment which biologists are mostly familiar with. Currently, it works as a standalone application online but integrating it into cBioPortal would be quite beneficial for cBioPortal users. In the first sub-project, including a read-only version of PathwayMapper into cBioPortal is aimed.</p> <p>NetworkView is a gene network visualization tool that is embedded into cBioPortal. However, it does not get along well with the cBioPortal codebase. Hence, in this second sub-project, the aim is to re-architect NetworkView module to make it compatible with cBioPortal codebase.</p>

<p><a href="https://knative.dev/" target="_blank">Knative</a> is an open-source community project that extends Kubernetes with modules for deploying, operating, and maintaining serverless, cloud-native applications. The serverless cloud computing model has the potential to improve developer efficiency while decreasing operating costs.The project idea is to develop Charmil, an open-source Golang-based platform that will serve as a package manager which assists in the discovery and installation of plugins from a community-curated plugin index. These plugins can then be embedded into any host CLI with additional features such as new version detection and smooth upgrades.Through Charmil, each CLI will be able to install other CLIs as extensions, thereby organizing them in a hierarchy. This functionality of Charmil will later be used to add new features on top of the Knative CLI.</p>

<p>Making information easily accessible to people, when and where they need it. Part of a greater effort to make Sugar more welcoming and maintainable.</p> <p>Script for end-to-end migration of <a href="https://wiki.sugarlabs.org/go/Activities#Sugar_Activities" target="_blank">activity documentation pages</a> from the Sugar Labs wiki, to GitHub(and simultaneously <a href="https://github.com/godiard/help-activity" target="_blank">help-activity</a>).</p> <h7>Impact:</h7> <ul> <li>Reduction in maintenance efforts.</li> <li>User-documentation moved to help-activity could just be downloaded once, and then read whenever needed; eliminating the need to have persistent internet connectivity.</li> <li>Contextual-help ( <code>alt</code> + <code>shift</code> + <code>h</code> ) from within another sugar-activity could also be made available, when the documentation resides at help-activity.</li> <li>Developer-documentation of sugar-activities, if kept at same place with the source-code in its GitHub-repository; would help developers/maintainers (they could be read and updated easily; without visiting an external link to the wiki).</li> </ul>

By linking their Apple Music account with ListenBrainz, individuals are able to use ListenBrainz to play their music selections. The integration into BrainzPlayer allows for this capability. By utilizing a content resolver, we can match the MusicBrainz Identifier (MBID) to the Apple Music catalog, permitting users to transfer playlists to their Apple Music account.

<p>There is an underlying issue with scale degree block as we have it now. The current block does not perform the function that musicians expect when they think of scale degree. Instead the block functions in a way that we can specify a key/mode of a pitch length, input a number and result is a pitch in the chosen key/mode.<br> The current block has its utility in programming and we aim to keep it as such with a modified name. A new block for scale degree needs to be added with the desired functionality</p>

The goal of this project is to improve the integration of PathwayMapper into cBioPortal as well as enhancing the full-blown, stand-alone editor version as follows. To do this, we will improve the integration of PathwayMapper viewer in cBioPortal and improve PathwayMapper editor. For the first problem, we have 3 subtasks: adding Pathways tab to Comparison Page in cBioPortal, investigating alternative or better ranking schemes for Pathways and resolving the issues and bugs in cBioPortal. To improve PathwayMapper editor, we have 6 subtasks: revisiting overall architecture of PathwayMapper to properly address different views in different contexts, integration of expand-collapse and hide-show operations for complexity management, incorporation of filtering and highlighting capabilities ,fixing the issues in ShareDB in collaborative mode editor, upgrading all third party libraries and resolving issues/bugs. Throgh GSoC, we will focus on these issues and solve them to improve the pathway views in cBioPortal.

<p>Casbin is an authorization library that extends its features to implement Access Control Lists, Role-Based Access Control, and Attribute-Based Access Control models in various programming languages to its clients. Casbin's Core Engine is written in GoLang. Casbin-CPP has obvious benefits of speed and efficiency compared to its implementation in other languages and thus, benchmarking is vital for the project to stand out from the rest. Python is the most versatile as well as the most used programming language and has huge community support. Casbin-CPP has the potential to support new PyCasbin to compound the benefits of both languages through language bindings and extension libraries. Currently, the project uses Microsoft Unit Testing Framework for C++ for testing and Microsoft’s Azure DevOps pipelines for CI. CTest is truly cross-platform and can be configured using GitHub Actions for consistent and better CI.</p> <p>Project Ideas are as follows:</p> <ul> <li>Modernizing the project with C++17 standard and Google’s benchmarking tool</li> <li>Implement Python bindings for Casbin-CPP using pybind11 library</li> <li>Implement testing based on CTest and set up workflows for Continuous Integration through GitHub Actions</li> </ul>

<p>Rust's procedural macros can be one of the more complicated and difficult to read sections of any codebase. A well-implemented and easy to use macro greatly improves a codebase by removing boilerplate code and user-facing complexity. My goal for the internship is to make the <code>ruma</code> macro crates readable and easy for newcomers to follow and add to. This will allow easier debugging and enable more people to review pull requests in the code-gen heavy crates. I plan to implement macro testing using <a href="https://github.com/dtolnay/trybuild" target="_blank">trybuild</a> or <a href="https://github.com/eupn/macrotest" target="_blank">macrotest</a> for both <code>ruma-events</code> and <code>ruma-api</code>. I will improve the error messages of the <code>proc_macro</code>s in <code>ruma-api</code> and <code>ruma-events</code> by using relevant spans and crafting helpful suggestions or examples to emit to the compiler, so the user knows exactly where and how to fix their code.</p> <p>The other goal of the project is to implement new code generation macros for the next breaking release version of <code>ruma-events</code>. The release will contain a major rewrite of how the event types are structured themselves and within collections. I will work on generating code for the new collection types and adapt existing code generation to the new API.</p>

Open-source developer portfolio and event hub for connecting open-source contributors and mentors.

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.