Explore Projects

The short term goal is to improve unit test coverage for PEcAn base packages. The overall PEcAn ecosystem of packages (e.g, models and analysis modules) are heavily dependent upon these packages, thus having a good test coverage for these would improve overall system reliability. The medium term goal is to increase the reliability of PEcAn’s integration tests, and thus my second round of package testing and refactoring will prioritize the packages that are most associated with overall workflow bottlenecks (e.g., PEcAn.data.atmosphere, which is focused on downloading and processing meteorological data). An added long term goal would be to document testing approaches to make adding tests more smooth and consistent across packages for future packages or functions that get on-boarded, thereby making them more maintainable and reliable.

This project aims to develop a hand-gesture computer control system by porting MediaPipe’s Gesture Recognizer to OpenVINO, enhancing performance on Intel hardware. It will have a context-aware system that maps hand movements to keyboard shortcuts, mouse clicks, and other inputs, with the innovation of application-specific mapping where identical gestures trigger different actions based on the active application. Deliverables include converted MediaPipe models (palm detection, landmark detection, gesture embedder, and classifier) in OpenVINO IR format with complete pipeline integration, a real-time gesture control system that achieves at least 20 FPS with smooth cursor tracking, and a user-friendly GUI for customizing gesture-to-input mappings; in addition, performance will be benchmarked across various Intel platforms and the implementation process will be thoroughly documented for future contributors.

To validate ecological models against new data sources, PEcAn researchers currently bypass the rigid, database-dependent benchmarking module, instead writing fragmented, "one-off" scripts. This project solves this by replacing the rigid benchmarking module with a highly flexible, general-purpose Validation Toolkit. Built entirely on R data frames, the toolkit extracts successful design patterns from existing scripts to let users ingest arbitrary data via YAML configurations (bypassing the database entirely), align time/space, and calculate statistical metrics. The toolkit will be rigorously tested on a Biogeochemistry Minimum Viable Product (MVP) using specific AmeriFlux sites and targeted global meta-datasets. Final deliverables include the fully documented Toolkit R Package, automated Quarto reporting templates, robust test suites, and an educational tutorial vignette.

This project aims to build a reliable OpenSCAD to JavaScript compiler using ManifoldCAD, making it possible to run existing OpenSCAD code in a modern JavaScript environment. The main challenge is that OpenSCAD works in its own ecosystem, while ManifoldCAD cannot directly execute OpenSCAD programs. Current tools are limited and often don’t handle modern features or correct semantics. To solve this, I will develop a proper compiler that accurately models OpenSCAD behavior instead of relying on JavaScript shortcuts. Building on my existing prototype, I will design a structured pipeline with parsing, semantic analysis, and an intermediate representation (IR) to ensure correctness. Key areas include handling modules vs functions, children(), special variables, and improving debugging through source mapping. The final result will be a robust, production-ready compiler integrated into the Manifold ecosystem, enabling developers to reuse OpenSCAD libraries with confidence.

<p>In addition to the interactive PEcAn web interface, the PEcAn API package is built to allow users to build the PEcAn settings object via an R script &amp; later send this object to a PEcAn instance running either locally or remotely. The PEcAn settings object is to be sent using the RabbitMQ API to the PEcAn instance.</p> <p>The prime objective of this project is to <strong>extend the PEcAn API package to achieve its full functionality</strong>. This involves leveraging the existing APIs &amp; creating new ones as per requirement for visualization purposes &amp; other PEcAn capabilities.</p> <p>This would allow a large number of members in the community to utilize the functionalities &amp; capabilities of the PEcAn Project directly through an R script. It would also enable developers to integrate the PEcAn project into other projects or software that rely on ecosystem modeling &amp; related phenomena.</p>

<p>A large goal of both the SBOL and synthetic biology communities is to develop a useful and comprehensive workflow from experiment to publication. Many SBOL-compliant tools already exist which perform distinct and useful functions ranging from component design, modeling, composition, simulation, figure creation, storage, sharing, and publication. In 2016, ACS Synthetic Biology recommended that all authors submit genetic designs using SBOL. An example workflow for doing so was published in 2016 (Hillson), and each of the parts of the workflow can be fulfilled by extant tools, but the integrations between tools can be made more robust. For example, the SynBioHub service allows for storage and sharing of SBOL parts, VisBOL allows for creation of SBOL visual images from SBOL files, and iBioSim and SBOL Designer allow for creation and composition of SBOL parts. SBOL Designer and iBioSim allow for upload of parts to an instance of SynBioHub, but there are many opportunities to improve this workflow with authentication, security, and sharing capabilities.</p>

Performance-focused, production-level machine learning libraries need to leverage the resources at their disposal to the maximum extent to deliver efficient and effective machine learning workflows that ultimately result in improved user experience. SparkNLP, one such library widely adopted and used by 16% of enterprise companies(as of Feb 2019), is currently capable of taking advantage of CPU optimization capabilities using Intel-optimized Tensorflow. This coupled with other optimizations already allows it to run machine learning pipelines orders of magnitude faster than legacy libraries. Such a library would benefit from solutions like OpenVINO that offer extensive integrations in the ML ecosystem and even further optimization capabilities for inferring and deploying models on a range of hardware platforms. Exposing the OpenVINO API bindings in Java will allow integration with SparkNLP to enable the above-mentioned capabilities, and furthermore, open up avenues for a large community of developers to benefit from OpenVINO’s rich feature set in the future.

<p>ABioTrans Plus is a web server for transcriptome data analysis and visualization. It supports the analysis of microarray and RNASeq data and performs ten different bio-statistical analyses that cover the common analytics for gene expression data. Furthermore, it gives the users access to several bioinformatics tools to perform 12 different bioinformatics analyses on gene/protein datasets. This project aims to develop ABioTrans Plus v3.0 which will support a wider range of high throughput omics data, namely MS-based proteomics and metabolomics data. Furthermore, developing a detailed report with the performed analysis with figures and data ready to be included in the publications. Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. Machine learning has been used broadly in biological studies for prediction and discovery.</p>

The existing GPU profiling workflow in OpenVino, through benchmark_app connects kernels to the model layers (primitives) and reports their execution times. However, this level of abstraction is too coarse to identify kernel instruction level insights. Intel GTPin, on the other hand, provides instruction level GPU kernel metrics like clock cycle counts, but is unable to directly map such metrics to specific inference or layers. This project aims to build a GTPin-centered profiling capability within OpenVINO to identify hotspot kernels and analyze their execution characteristics. The approach involves integrating controlled GTPin profiling into the inference flow, developing a custom GTPin tool for collecting kernel-level metrics, and progressively interpreting these metrics using signals from OpenVINO performance counters, and kernel metadata. The expected deliverable is a GTPin-based profiling workflow integrated into OpenVINO, capable of identifying bottleneck kernels, providing insight into their behavior, and offering indicative optimization directions, with validation using tools such as VTune.

<p>The current rebar functionality in FreeCAD is very limited by its UI and creating a reinforcement system using it is quite tedious. Currently, the user has to create a sketch for the rebar profile and define the required set of constraints. This becomes very time-consuming task even for an expert level user when he/she has a building model with several structural objects. This project is aimed at easing up the process of rebaring in FreeCAD. In this project, list of rebars will be provided to user in the form of dropdown. On selecting a rebar from dropdown, a dialog box will popout with input fields where can provide data related to selected rebar. The entire project will be delivered as a FreeCAD addon. The input fields in the dialog box are further categorised and presented in the form of tabs. User can easily switch to any tab to see contained input fields, thus enriching the experience by keeping the natural flow of user. With successful completion of this project, FreeCAD user will have an easy and professional way to create rebars for their projects with less efforts in less time.</p>

<p>Visualizing genetic circuits is essential in the field of synthetic biology. These genetic designs often involve complex representation of modular and hierarchical biosystems. The representations are standardized through the Synthetic Biology Open Language (SBOL) in the form of glyphs. To make the visualization of biocircuits more efficient and amenable to automation, my goal is to upgrade DNAplotlib to support highly customizable visualizations of genetic circuits from SBOL version 2 files. I will achieve this by integrating DNAplotlib with the pySBOL2 library to support reading and writing of SBOL2 files. The current DNAplotlib only support SBOL 1.0 documentation, and thus is only capable of manifesting DNA components consisted of DNA sequence and sequence annotation. It cannot represent complex interactions between different subcomponents, and thus has poor connectivity with other genetic platforms. Through my work this summer, DNAplotlib will (1) incorporate non-DNA components / partially complete design sequences (2) document and link to external models such as SBML and CellML (3) visualize hierarchical and modular biosystems (4) save customization into SBOL file.</p>

<p>GeneTech allow users to develop genetic logic circuits only by specifying a Boolean function. The tool first performs Boolean optimisation, followed by synthesis and technology mapping. Currently, a user can define the desired behavior in the standard Boolean notation. I would like to add the support for designing a circuit via drag and drop method on a design canvas. This functionality would allow users, specially electrical/electronic engineers, to design a genetic circuit by constructing the circuit schematic on a design canvas using drag-drop-wire approach. GeneTech will then transform the circuit schematic into the corresponding genetic circuit and represent it in the standard SBOL notation. The results produced by the current version of GeneTech do not include the DNA basepair encoding of circuit components. I would like to update the tool to be able to embed the DNA sequence of generated circuits in the SBOL file.</p> <p>Most of the code-base of GeneTech is currently a pre-compiled version of the Java code which adds additional overhead and dependencies. We would also like to convert the Java code to Python and reduce dependencies along the way</p>

MaREA4Galaxy is a user-friendly tool designed to facilitate the characterization and graphical comparison of sample groups exhibiting distinct transcriptional regulation of metabolism, as inferred from cross-sectional RNA-seq data. The overarching goal of this project is to enhance the MaREA4Galaxy environment by integrating various omics data types, such as gene expression, proteomics, and metabolomics, enabling researchers worldwide to conduct constraint-based enrichment analyses of metabolic pathways. The key enhancements include two primary features: 1. Flux Sampling Interface: This feature provides users with the capability to sample fluxes through cobra models utilizing methods like CHRR (Coordinate Hit and Run with Rounding) and CBS (Corner Based Sampling). 2. Feature Loading Interface: Users can load diverse features for a given set of samples, including RNA-seq data, RAS data, sampled fluxes, metabolomics, and proteomics, initiating a clustering analysis. Subsequently, leveraging the MaREA tool, enriched metabolic maps are generated. Additionally, users gain the ability to compare different clusters derived from the input datasets.

<p>Currently, FreeCAD's IPython and Jupyter Notebook integration can only provide visualization by running the entire FreeCAD GUI alongside the notebook. Besides not being elegant it brings many problems with it, like not being able to save the visualizations inside the notebook for sharing or bringing visual complexity of the entire GUI into the view instead of just displaying the 3D model. It is therefore important to find a way to visualize FreeCAD's 3D scene in the IPython display system as supported by Jupyter Notebook.</p> <p>Tackling the open issue “IPython / Jupyter support” I aim to implement a IPython compatible visualization of FreeCAD’s 3D Open Inventor scene graph. To achieve this I intend to choose a suitable JavaScript library able to render a 3D scene graph and to implement a mapping between it and the Open Inventor scene graph. After this as a byproduct I want to implement a better WebGL export based on the scene graph instead of document objects as currently found in FreeCAD. For this I can reuse and integrate the scene graph mapping component. Lastly I want to document the results in the Wiki and create an example Jupyter notebook.</p>

We usually need visualization, in fact, to enhance the interpretability of data or results, and facilitate the understanding of developers and users. In machine learning, 3D or 4D representation provides more depth information than the 2D representation, many of the tasks may be much better understood if we provide a 3D or 4D. But OpenVINO has no native real-time 3D visualization engine or library. This can be very troublesome for users who use display 3D images. So our goal is working natural 3D support for Jupyter Notebooks running OpenVINO (AI inference). There are a few solutions in Jupyter 3D graphic display, though: 1. Requires complex setup, build or is not friendly to the average user (without graphics programming experience) 2. Not integration with OpenVINO(Need process different data and different inference results available from OpenVINO, the user only needs a simple interface to set this up) The project idea aims at fill in the gaps mentioned above: 1. Provides a clean interface to set up the display of these graphics without the need for a graphical programming background(beginner-friendly) 2. 3D support for Jupyter Notebooks running OpenVINO(Be able to transform and process the output data of OpenVino)

<p>In this project the multi-objective mean-payoff properties in Markov decision process are to be added into Prism, which is a probabilistic model checker. In this project the following things are done to Prism:</p> <p>• Multi-objective mean-payoff properties support in Markov decision process is extended, namely the algorithm defined in [1] is planned to be added. This should be based on the already existing MultiGain.</p> <p>• A conversion algorithm for f LT L (GU ) formulae to a MOMP, defined in [2].</p> <p>• The (already existing) Rabinizer for converting LTL to DTGRA, be- cause it heavily intersects with the conversion algorithm for f LT L (GU ) .</p> <p>[1] Chatterjee, Krishnendu, Zuzana Komarkova, and Jan Kretinsky. ”Uni- fying two views on multiple mean-payoff objectives in Markov deci- sion processes.” Logic in Computer Science (LICS), 2015 30th Annual ACM/IEEE Symposium on. IEEE, 2015.</p> <p>[2] Forejt, V., J. Krcl, and J. Kretnsk. ”Controller synthesis for MDPS and frequency LTL GU (2015).” CoRR, abs/1509.04116.</p>

Java-Ranger is a path merging extension of Symbolic Pathfinder, that collapses multiple execution paths into a single region with a disjunctive constraint. Currently, it handles only integer constrains, which means, floating-point (FP) operations are either approximated unsoundly or cause solver errors. In this project, the aim is to add sound IEEE-754 floating-point support to Java ranger, enabling the correct summarization of regions containing FP arithmetic, comparisons, conversions, and library calls. The work heavily involves refactoring the underlying FP support in SPF (Modelling special values, rounding, comparisons, and conversions), then extending Java Ranger’s AST visitors, merging heuristics, and solver integration to handle the new FP constraints. The result will be an engine capable of analyzing FP-Java programs. Deliverables include: - New floating‑point expression nodes in the numeric package. - Updated bytecode handlers for all FP instructions. - Solver integration for Z3bitvector using the floating‑point theory. - Constant folding and simplification passes for FP expressions. - A test suite validating the correctness and coverage of FP handling. - Documentation of the new API and usage.

This project aims to resolve the computational bottleneck in self-collision detection within the OCS2 framework for humanoid robotics. The current implementation in ocs2_self_collision operates on a pair-by-pair basis, iterating through collision pairs and calling PinocchioGeometryInterface::computeDistances() followed by Jacobian and penalty term calculations. This sequential approach is not SIMD-friendly by default and fails to utilize the parallel processing power of modern CPUs. To address this, I propose replacing the current computeDistances()-based distance computation with a high-performance implementation inspired by SIMD-amenable structures. A primary focus will be exploring / integrating SIMD-friendly data structures, such as Collision-Affording Point Trees (CAPT), to represent the storage and computation of collisions. This transition aims to transform the collision pipeline into a vectorized workflow that can be efficiently accelerated using AVX2 intrinsics. The primary deliverables include the clean integration of this accelerated engine into the ocs2_self_collision pipeline, accompanied by rigorous correctness checks against Pinocchio/FCL baselines. Furthermore, I will provide a comprehensive end-to-end latency evaluation using ocs2_mobile_manipulator to demonstrate the reduction in average and maximum compute cycle times. This work will significantly enhance the real-time performance of MPC-based humanoid control in complex environments.

This project aims to develop a Direct GitHub Integration Plugin for PathVisio to transform the pathway curation workflow from outdated systems to the WikiPathways GitHub repository. This proposal delivers a Java-based plugin which uses GitHub REST APIs to carry forward Git Operations. The PathVisio-GitHub Integration plugin will provide a clean and user friendly UI for biologists unfamiliar with Git Operations. The main goal of this proposal is to build an automation of Git Operations directly from PathVisio to WikiPathways GitHub repository for WikiPathways contributors. The plugin features authorization of users via GitHub using OAuth Device Authorization Grant and provides automatic forking of repositories and branching in the background using GitHub REST APIs. An encoding of GPML pathway files into Base64 format takes place before the plugin stages commits and opens Pull Requests directly from the PathVisio dashboard without freezing the main application thread. This is ensured by Java SwingWorker running in the background. Furthermore, the project integrates GitHub Actions to automatically validate file formats and metadata completeness upon final submission. Ultimately, this plugin helps to simplify complex Git operations of contributing to biological pathways, enabling the global biological research community to effortlessly work on PathVisio.

<p>OpenSCAD is a FOSS which belongs to the CAD software category. It allow users to describe the CAD model using codes/scripts, and using those scripts; it renders the output. Due to the continuous community contributions, the OpenSCAD software comes fully packed with useful features and widgets. Just like any other FOSS, there are still some scope of improvements suggested by the community that can enhance the user experience. Some of them are -</p> <h4>User-Defined Shortcut Configuration:</h4> <p>Allowing the users to set custom-shortcuts through a configuration file and a GUI.</p> <h4>Making Text Editor more interactive:</h4> <p>Allowing the users to scroll the values/numbers via mouse</p> <h4>Jump to Error Location from Console Box:</h4> <p>Allowing the users to jump directly to the error location inside the Text Editor, on clicking the error/warning message inside the Console.</p> <h4>A new ‘Error Log’ dockable widget</h4> <p>It will log all the error/warnings reports, with the ability to allow the users, to jump directly to the error/warning location inside the Text Editor, just by tapping the error entry from the log.</p> <p>My aim during the project will be to implement the above-mentioned features and enhancements.</p>

VCell-AI is an AI-powered platform for discovering, analyzing, and exploring biological models from the VCell database. While the platform already provides a functional chatbot interface, it requires additional capabilities to support real-world usage — including authentication, usage control, and broader integration with scientific data sources. This project aims to extend the system across these dimensions. Auth0 authentication will be integrated using the existing VCell Auth0 tenant, allowing existing VCell users to log in seamlessly. On top of this, a per-user token tracking and enforcement system will be introduced, along with an admin dashboard for managing limits. The prompt handling layer will be refactored into a centralized registry to improve consistency and reduce fragmentation. Local LLM support will be exposed as a user-facing feature. The system will also be expanded with PubMed search, complementing the already implemented BioModels DB integration. To improve usability, BNGL-based molecular visualization will be integrated. Support for SBML data will be completed, and BioPAX pathway data will be introduced as an additional source for biological knowledge. Prior to the coding period, 8 pull requests have already been raised covering API standardization, local LLM bug fixes, and BNGL visualization integration as a proof of concept, demonstrating familiarity with the codebase and commitment to the project.

Industry Foundation Class (IFC) is the leading open data format for the built environment, based on the ISO 16739-1:2018 standard. It’s the foundation of the openBIM workflow. Today, IFC is most often used as a software-agnostic way of exchanging building information, but there is increasing interest in using the IFC schema as the native format for working with BIM data. Blender, with its mature modelling and rendering capabilities, has the potential to become a powerful BIM authoring tool. Open data and integrated python console already give many options for customising the data and meta data of any geometric object. The BlenderBIM plugin introduces the possibility to assign the properties of IFC classes to native blender geometry and export correctly structured IFC files through the use of the IfcOpenShell software library that already contains many useful functions to work with the IFC schema. The goal of this project is to develop a plugin for the visual scripting language for Blender, Sverchok, that would enable creating IFC geometry and data through the visual programming nodes, allowing the users to create their own parametric workflows and incorporate IFC data directly into their design process. An equivalent plugin for Sverchok, would allow an integrated parametric design and native IFC workflow to be completed fully inside the FOSS environment. It would also be a strong foundation for integrations with other Building Performance Simulations (BPS) tools. Integration and porting of the nodes to FreeCAD would also be possible. Some of the basic nodes are already coded under the IfcSverchok project. The work will involve testing the existing nodes and writing many more to support the full use case. Since the IFC schema is very large, and often difficult to grasp for new users, emphasis will be on integrating the concepts of IFC into a typical design process in a natural manner and communicating the relevant information comprehensively to the user.

This project entails the creation of a GCBM Simulation Editor for the FLINT-UI. Currently, all of the configurations for running the simulation are stored in a JSON file and uploaded. In this project, the configuration interface with proper labels, interface for running the model and finally downloading the output is to be created. This will enable scientists and researchers to configure the GCBM Run easily using a simple User Interface.