Explore Projects

<p>LibRoadrunner is a high-performance SBML based simulator for Systems and Synthetic Biology that uses LLVM to generate very efficient runtime code. SBML Arrays package is under development and provides support for expressing an array of components of a computational biological model. Arrays make it easier to represent large complex regular systems in a standard way. Currently, iBioSim is the only tool that supports SBML arrays. The goal of the project is to implement “SBML Array” support in libRoadRunner and ensure compatibility between libRoadRunner and iBioSim so that models can be exchanged correctly.</p>

<p>Modelling wind flow through a city has many applications, such as studying the effect of natural ventilation or looking at pollution levels. Solving the full Navier-Stokes equations over a domain the size of a city in 3D would be prohibitively expensive. Fast fluid dynamics (FFD) present an opportunity to solve a simplified version of the incompressible Navier-Stokes equations very quickly. In this project I would like to implement FFD to model wind flow through a city, and then apply FFD to solve an optimization problem. Unfortunately I didn't have enough time to come with a specific optimization problem, but there are no doubt several that would be interesting.</p>

The project aims to enhance the reliability of PEcAn's integration tests by prioritizing packages associated with overall workflow bottlenecks. It will commence with breaking down workflows to meaningful sub-sections and confirming their dependability by rigorous testing effort. We then prioritize basic runs to establish a robust foundation that include single site, single model runs to cover the major models. Subsequently, attention will shift towards ensemble runs, diversifying testing scenarios to ensure comprehensive coverage. We move ahead to automating these tests and running them on a more regular basis to maintain system correctness with every new in-coming change as development proceeds.

<p>OpenSCAD is an open-source 3D modeling software. It uses two main modeling techniques namely, Constructive Solid Geometry (CSG) and extrusion of 2D Outlines. OpenSCAD at its core uses CGAL for geometry evaluation and OpenCSG and OpenGL for rendering. OpenSCAD performs huge computations in the process of creating the required geometries. These geometries are stored in the cache for avoiding repetitive computations. But this cache data is not persistent and destroys when the application closes. The goal of this project is to create a persistent cache system for OpenSCAD which uses a key-value datastore to store cache. This implementation will handle a cache similar to the existing one.</p>

<p>Prism is a tool for probabilistic model checking. It is categorized as a formal verification system tool for the modelling and analysis of systems that exhibit probabilistic behavior. Prism allows its users to plot the results of its various experiments graphically, but currently only a small range of graphs is supported. This proposal addresses the extension of the graphing capabilities of Prism by adding the support of many new 2D and 3D plots. This feature would enable the users of Prism to easily grasp and compare the results of the experiments run on this tool without having to go through the text output results. This project also addresses the enhancement of the general GUI of Prism. This would focus on making this tool more flexible and usable.</p>

OTX supports 15+ detection models but has no built-in tracking.Every real-world video application (conveyor belt counting, asset monitoring, dwell-time measurement, traffic analysis, sports analytics, etc) needs stable object tracking across frames. This project integrates Multi-Object Tracking into OTX, adding five tracker implementations (ByteTrack, SORT, DeepSORT, OC-SORT, BoT-SORT), a SAM-2-inspired memory bank for re-identification, MOT17 benchmarking, and CLI support along with documentation. The design is decoupled: a new OTXTracker base class owns all temporal state while existing OTX detection models remain untouched.

Saikei Civil is an initiative to bring professional roadway design capability to Bonsai/IfcOpenShell. The goal is to add tools, features, and functionality to Bonsai that will enable BIM-type modeling of roadways (and eventually other horizontal infrastructure), making use of the IFC 4.3 schema. This proposal aims to deliver the core tools for roadway design in 3 milestones: Vertical alignments (horizontal already implemented), Cross-section profiles, and Corridor generation. Once complete, Bonsai will be the first program capable of roadway model authoring natively in IFC, eliminating massive time and effort toward export processes, and will prevent large amounts of data loss from said exports.

I will extend the existing OpenVINO GenAI text-to-image pipeline to support image-to-image functionality by incorporating ControlNet and utilizing the OpenPose detector. Additionally, I plan to create a new image-to-text pipeline using the CLIP model. Lastly, I will develop a cross-platform GUI using Qt to showcase these pipelines. I will deliver: 1. An image-to-image pipeline. 2. An image-to-text pipeline. 3. A cross-platform GUI. And if possible, more controlnet model could be implemented into image-to-image pipeline. Additionally, I'll explore the generation speed on CPU only, with integrated GPU (iGPU), and with the Intel Arc A770 GPU. I'll also investigate if I can build more similar projects using OpenVINO.

Configurable linter for Concerto (used in the Accord Project) validates syntax and the JSON AST of Concerto models against a curated set of Spectral rules. Rules enforce best practices : such as naming conventions (e.g., camelCase properties, PascalCase declarations) and feature restrictions (e.g., reserved keywords), while remaining fully configurable per project. Lint results surface in the concerto CLI. The tool is designed to be lightweight and performant; it integrates seamlessly with existing concerto tooling and supports extensible rulesets packaged as npm modules. Overall, the project advances Concerto by reducing manual checks, improving model quality, and providing practical rules informed by real user needs, backed by comprehensive testing and easy configuration.

Unsupervised anomaly detection models in Anomalib rely on synthetic anomalies to calibrate decision thresholds, but the current Perlin-based pipeline produces unrealistic and static anomalies, leading to unstable threshold estimation and poor generalization to real defects. This project proposes a hybrid, on-the-fly synthetic anomaly generation pipeline that combines multi-scale fractal masks with self-sourced Poisson blending to generate realistic, localized anomalies with controlled difficulty levels. By generating diverse anomalies dynamically during validation, the model can learn a stable and reliable decision threshold without requiring labeled anomaly data. The project will deliver a structured literature survey, integration of the proposed pipeline into Anomalib, and a benchmarking study comparing it with the current baseline using PyTorch and OpenVINO, focusing on threshold stability, detection performance, and CPU efficiency.

The field of computational biology depends significantly on mathematical modeling to simulate complex biological simulations, often involving solution of large systems of ordinary differential equations, which describe dynamic biological processes. Accurate and efficient numerical solvers are essential for these simulations to predict correct behaviour. LSODA (Livermore Solver for Ordinary Differential equations Automatic) is a well-established ODE solver known for its ability to dynamically switch between stiff and nonstiff methods, making it particularly suitable for biological models where stiffness can vary over time. However, LSODA’s widely used implementations are primarily in C/C++ and Fortran, creating a barrier for researchers working in Java-based environments. This project aims to bridge that gap by implementing a robust, optimized, thoroughly tested, and fully functional Java-based version of the LSODA algorithm within the Systems Biology Simulation Core Library (SBSCL).

<h3>libGPML</h3> <p>Currently it is required to include the whole <a href="https://github.com/PathVisio/" target="_blank">PathVisio</a> core module which is much bigger and already contains PathVisio specific visualization aspects, also with the current data model it is difficult to find out the connections between two elements in the pathway. This automatically makes any graph algorithms which could be used to analyse the pathway very inefficient.</p> <p>A general GPML library should only contain the data model, the functionality to read and write <a href="https://www.pathvisio.org/gpml/" target="_blank">GPML</a> files and relevant importers and exporters to other often used file formats so it can be easily integrated in other applications.</p> <p>The main goal of this project is to create a separate GPML library to read and write GPML files in Java which can be used by PathVisio, the WikiPathways app for Cytoscape and many other applications.</p>

[Problem] The project aims to enhance the runtime performance of OpenVINO on RISC-V devices to fully leverage their power efficiency for running DL/AI workloads efficiently. [Methodology] This will be achieved through three key optimization strategies: adopting or improving third-party libraries with RISC-V optimized primitives, porting existing x86/ARM optimized kernels to RISC-V ISA, and implementing device-specific transformation passes tailored for RISC-V backend optimizations. [Deliverables] The project will deliver: 1. Adoption of optimized RISC-V kernels from third-party libraries for more operations in OpenVINO. 2. Porting of critical x86/ARM optimizations to RISC-V ISA. 3. Implementation of device-specific transformation passes for RISC-V backend requirements. 4. Demonstrated improvement in OpenVINO runtime performance on RISC-V CPU devices through benchmarking against determined workloads.

<p>The PEcAn (Predictive Ecosystem Analyser) project is an open source system for ecosystem modelling and forecasting. With huge amount of climatic and environmental data available, the PEcAn software tries to utilize it for providing users vital statistics and interactive visualizations for modeling and forecasting. Integration with Google Maps interface provides helpful information to the user and it becomes very handy to select a site. PEcAn already has an interface with Shiny (R) for visualizations and the main aim of this project would be to work upon the existing Shiny apps as well as developing other powerful visualizations to convey the right amount of information as well as clear understanding to the users on the platform. For me, an important component of this project is to understand what kind of visualization would give an intuitive sense to any user given the data and to present them in a very clear and effective manner. Otherwise, the user could not draw inferences that we want to show them. This is the most interesting thing I like and it is my motivation to work on this project to master this art of visualization.</p>

Modern messaging platforms like Discord and Slack are not just used for communication but also for consuming news, discussions, and topic-specific updates. However, keeping track of all this information across channels is overwhelming. This project aims to build a privacy-preserving, offline desktop AI assistant that can retrieve and summarize past messages using a local Retrieval-Augmented Generation (RAG) pipeline. Leveraging Intel's OpenVINO 2025 Generative AI workflow and LangChain, the assistant will extract messages via the Discord API, embed them using OpenVINO-accelerated models, and store them in a FAISS vector database. On receiving a user query or generating a daily digest, the system retrieves relevant context and runs inference using a locally optimized LLM, accelerated by GPU, NPU, or CPU depending on available hardware. A PyQt-based desktop application server as the user interface, providing features like chat, digest summaries, model/device selection, and system notifications.

<p>BuildingSMART organisation is currently working and about to publish new <a href="https://github.com/buildingSMART/IDS" target="_blank">IDS</a> (Information Delivery Specifications) which in simple terms is a machine-readable standard for building information modelling (BIM) requirements. Thanks to IDS, it is possible to automatically verify exchange requirements of BIM models delivered in IFC format.</p> <p>In my project, I will first focus on the validation process using IfcOpenShell to make sure it fully supports the new XSD (XML schema definition) of IDS and create sample IDS files to test it against. Furthermore, I aim to enhance this feature with BIM Collaboration Format (<a href="https://technical.buildingsmart.org/standards/bcf/" target="_blank">BCF</a>) output of such verification, which will be integrated into the BIMTester tool.</p> <p>The last step would be to allow for easier creation of IDS files by non-coding users. The idea is to add the authoring functionality of BIMTester web UI. This is where the work overlaps with the project of another GSoC student.</p>

<p>The Infobiotics Workbench (IBW) is a synthetic biology design tool with three major functionalities: stochastic simulations, which mimic the procession of complex biological pathways; verification of simulation rulesets; and biomatter compilation. Its simulations are driven by designs written in the domain-specific Infobiotics Language (IBL), which contains data that is then sent to the Biocompiler to be built into a Biocompiler Model internal structure.<br> Currently, IBW offers limited support for two standard biological languages, the functionality-based Systems Biology Markup Language (SBML) and the design-based Synthetic Biology Open Language (SBOL), a common medium of exchange for synthetic devices. While SBML is made use of by the simulation aspect of IBW, the design-based SBOL is used by the Biocompiler as a format to write its compiled design into. This project aims to enhance the Biocompiler’s ability to export and import SBOL and SBML. If IBW’s capacity to work with these two biological modelling standards is improved, its accessibility to computational biologists around the world would increase dramatically. Hence, this project will enable this integration.</p>

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.

A lot of everyday computer tasks—like navigating applications, managing files, and configuring settings—are repetitive and require multiple manual steps. Existing automation solutions rely on brittle scripts or cloud-based AI systems, which introduce latency, privacy concerns, and limited adaptability. This project aims to build a native desktop GUI agent that can understand natural language instructions and autonomously operate the computer interface. The system will combine Vision-Language Models (VLMs) for screen understanding and Large Language Models (LLMs) for reasoning and task planning, all running locally using OpenVINO for efficient, low-latency inference. The proposed solution uses a multi-agent architecture consisting of a Router, Planning, UI Grounding, Action Execution, and Reflection agents. The VLM (Phi-3.5 Vision) will interpret screenshots and map UI elements to coordinates, while the LLM (DeepSeek-R1 Distill Qwen 7B) will decompose tasks and generate action sequences. A PyQt-based desktop interface will allow users to interact with the agent, monitor execution, and configure settings.

<p>The Systems Biology Markup Language (SBML) is the main language for representation and exchange of computational models in biology. JSON is the main data format of the web. Currently, many issues exist with the JSON representation of SBML used by tools like cobrapy, escher, ModelPolisher or the BiGG database.</p> <p>The idea of this project is to update the JSON scheme to have a full coverage of features important for constraint-based methods, i.e. SBML core and the additional SBML packages fbc and groups. In addition, existing issues related to SBML-JSON will be solved. The project will be implemented as part of cobrapy with main focus on the following:</p> <ol> <li>Annotation and meta-data support will be implemented</li> <li>Validation of JSON-SBML files will be performed</li> <li>Roundtripping SBML-JSON-SBML without information loss will be implemented</li> <li>JSON (SBML) scheme and scheme validation will be implemented</li> </ol> <p>Hence, a full-featured JSON exchange format for SBML will improve the web-integration and exchange of SBML models on web.</p>

This project develops an AI-powered desktop application for real-time traffic monitoring and intelligent automation. It detects vehicles, pedestrians, and traffic violations (e.g., Red-Light jumping, Improper Stopping Over Crosswalk at RedPedestrian Right of way Violation Detection) across multiple intersections, providing actionable insights for smart city traffic management. The system leverages YOLOv11 for object detection, trained on a combination of synthetic and real-world traffic data. Synthetic scenes are generated using CARLA, ensuring robustness under diverse and challenging traffic conditions. Detection models are optimized with OpenVINO for deployment on edge devices such as CPUs, integrated GPUs. A desktop dashboard built with PySide6 (Qt6) provides live video feeds with detection overlays, multi-camera support, and performance metrics. Multi-object tracking is implemented using ByteTrack for persistent identification of vehicles and pedestrians. To enhance scene understanding, Vision-Language Models such as Mistral is integrated, generating concise textual summaries of traffic patterns and contextual information for detected violations. Real-time analytics, IoT integration with MQTT, and visualization via InfluxDB and Grafana enable actionable insights for urban planning and automated law enforcement.

BRL-CAD is a battle-tested Constructive Solid Geometry (CSG) engine, but it currently lacks a native, bidirectional interface for headless command execution, creating a massive barrier for modern web integrations and AI agents. This project proposes building BRL-CAD’s first native, extension-agnostic C++ Local IPC (Inter-Process Communication) API. By securely binding a stdio-based pipe listener to the main event loop and leveraging native libbu utilities for memory-safe string parsing, this infrastructure will allow users to safely pipe commands directly into the libged database engine. Designed with a "generic passthrough" architecture, it avoids hardcoding 400+ command schemas and ensures frictionless portability to BRL-CAD’s upcoming MOOSE/Qt interface. Alongside this foundational API, the project delivers a robust Model Context Protocol (MCP) server to establish BRL-CAD's first native Agentic AI integration. Operating externally as decoupled Python-based FastMCP middleware, this daemon bridges the legacy C-engine with modern Large Language Models. Rather than embedding a bulky AI chatbot inside MGED, the user interacts through their preferred external MCP client (like Cursor IDE or Claude Desktop), which routes commands directly into BRL-CAD's new background IPC pipeline. This empowers users to seamlessly query native documentation, automate batch database tasks, and debug spatial relationships using conversational commands, drastically lowering BRL-CAD's onboarding friction.

<p>The GTK client (Tryton) already has CSV Import/Export feature. This project would implement the same feature in web client (SAO) keeping the behavior similar.</p>