Explore Projects

Time to First Plot (TTFP) is one of the most disliked things about Julia language because it takes from seconds to minutes to produce the first output. This is caused by the underlying Just-In-Time compilation, and the current solution is to build a user system image containing pre-loaded libraries with precompiled code. However, the workflow is primarily manual, and users are forced to recompile the system image after any package update. Currently, Julia's developers work on introducing system-image-like blobs containing compiled native code for a specific package. However, both these methods compile only package-specific precompile statements by default, and the project will introduce a new package to change this paradigm. The package would collect precompile statements during normal usage of Julia and offer to recompile the system image (or blobs) once the libraries are updated. The provided images would fit the specific user's needs and contain compiled code that would not be compiled by the default.

This project aims to implement the necessary infrastructure for the Discontinuous Galerkin method in the finite element toolbox Ferrite.jl. This will include writing examples, documentation, and tests. DG method is a FEM like the continuous Galerkin (CG) method where the test functions are chosen to be the same as the trial functions. However, DG elements do not share degrees of freedom (DoF) at common nodes, introducing extra DoF and adding the process of choosing coupling between elements through numerical fluxes. The main deliverables are: • Methods to integrate on inner faces. • Extend the methods to integrate over subfaces. • Sparsity pattern methods for DG. • Implement infrastructure for handling boundary conditions for DG approximations. • 1-D, 2-D, and 3-D steady heat equation using DG example. • Testing and documentation for all implemented methods.

<p>This project aims to get the GraphBLAS API working from Julia by connecting it to the SuiteSparse GraphBLAS implementation and creating a graph type backed by the methods provided in the library.</p>

<p>One of the major challenges faced when applying model checking is the state space explosion, due to which it becomes impossible to detect errors in many cases. The main aim of this project is to utilize multiple cores for state space exploration in order to achieve massive speedup.</p>

<p>[Nakade et al. 2018] proposed to model check Habanero programs using only one program run. This project aims to further reduce state space being explored by considering symbolic graph instead of concrete one. Habanero synchronization primitives are used to guide SPF execution.</p>

<p>Symbolic Pathfinder (SPF) is an open-source symbolic execution tool, based on NASA Java Pathfinder (JPF) model checker, which is used in research and industry labs. It executes Java bytecode using a custom JVM to perform its analysis. We propose to add support for symbolic execution of complex datastructures, especially arrays, and to implement a module to generate concrete inputs and replay symbolic execution with concrete variables.</p>

<p>JPF is a model checking tool for java applications. JPF-core is the core structure of JPF. The build for jpf-core has been moved from ant (upto java 8 support version)to gradle. The current JPF-core version doesn’t have java 11 support i.e jpf-core is not portable for java 11. Jpf extensions have not moved from ant to gradle yet. This is because of the potential breaking changes from its previous versions. One such major breaking change in java 11 is “bootstrap methods”. The goal of this project is to fix gradle support for java 11, to update the extension template,provide the widely used jpf-extensions with gradle support.</p>

<p>JPF is a model checking tool for Java applications. It is a Virtual Machine (VM) for Java bytecode which executes the system under test (SUT). The JPF source is partially compatible with Java 11. The problem is to support new features of Java 11 like the bootstrap methods. They are used for things as common as string concatenation ( String + String, String + int, String + double, String + Byte, etc ). As of now, a few specialized cases are supported, but there are still few cases that fail with Java 11. There are also some internal APIs from Java 11 that no longer exist in Java 12. Therefore the aim of this project is to support the general case of bootstrap methods and update the code to support java 12.</p>

<p>Symbolic Pathfinder (SPF) is an open-source symbolic execution tool, based on the NASA Java Pathfinder (JPF) model checker, which is used in research and industry labs. It executes Java bytecode using a custom JVM to perform its analysis.</p> <p>It currently uses <em>lazy initialization</em>, a brute-force enumeration of all heap objects that can bind to the structured inputs accessed by the program. This explicit enumeration may lead to a huge amount of false alarms.</p> <p>We propose to explore alternative ways of representing constraints over the heap. This would allow SPF to avoid a complete enumeration of all the possible cases, eliminating the ones violating the data structures properties. We want to focus in particular on separation logic and see if it brings an improvement compared to the lazy initialization or to languages like [1].</p>

<p>Java PathFinder (JPF) has potential to be used for verification of Android apps, as they are written in Java. There is already an ongoing project to use JPF to verify Android apps outside of the Android platform, but such approach has limitations on the app functionality that can be verified, because modelling of Android environment on the desktop is difficult. Moreover, some apps cannot be properly analyzed in this way, as they rely on system events, make native calls, or interact with other Android apps that are unavailable outside the platform.</p> <p>We propose an alternative approach: to create a fork of JPF and its extensions for Android platform. We plan to create an Android app that includes all sources of jpf-core, with necessary modifications, wrapped in the user interface (UI). The UI will start main method of underlying jpf-core, provide to it command line arguments, and display output. The underlying JPF will be executed as service.</p>

<p>Eye tracking has many applications from driver safety to improved accessibility for people with disabilities. There exist expensive and bulky hardware solutions for eye tracking but this project aims to bring robust and accurate eye tracking to everyone. Recent research and the pervasiveness of handheld devices with powerful cameras have now made it easy to have high quality eye tracking right in our pockets!</p> <p>The aim of this project is to allow researchers and developers all over the world to use our open-sourced eye tracker (with additional features) in new and varied use cases. From simple systems where the phone can be mounted on a stand in a vehicle to track multiple parameters of the driver – drowsiness, gaze, attentiveness to more complex applications like emotion analysis and even lie detection, the sky's the limit.</p>

The "NWB File Compatibility Testing and Summary Generation via Docker" project aims to streamline the process of testing NWB (Neurodata Without Borders) files for compatibility through the utilization of Docker containers. NWB files are commonly used to store neuroscientific data, and ensuring their compatibility with various software environments is crucial (NWB Explorer in particular). By employing Docker, the project facilitates consistent and reproducible testing across environments under observation. The project also involves the automated generation of summary files, which provide concise insights into the compatibility status of NWB files. This endeavor ultimately enhances the efficiency of assessing file compatibility while promoting standardized practices within the neuroscientific community.

<p>The purpose of this project is to create functions which convert a wxMaxima worksheet to Texinfo. The functions to convert a worksheet will be written in Common Lisp, which is the implementation language for Maxima itself.</p>

Editing CSV/Displaying CSV files CSV file viewing and sorting for AnalySim datasets, that can be sorted and filtered. I will study how to create and edit/delete CSV files using javascript, From here i will convert the CSV into an .html Table to be shown to the user Implementation of selecting columns and constraints that filters the data based on these conditions Account Confirmation Email Will have a backend implementation to ensure that the email is functional and confirmed. When creating an account, a link should be sent to user’s email, and when clicked it should be confirmed on the backend that the account is valid .net core framework to add code into the database to verify the email. Getting permission from project owner This function will enable the owner to select people that they want to work with on their project. Ensuring permission will prevent any bad actors from messing up a project. Add an invite notification when an owner invites a collaborator to the project Enable editing/admin permission to requested user/collaborator

This project proposes a modular, real-time gesture-to-sound mapping framework for the GestureCap system. It will enable users to translate hand gestures into expressive audio control for music and speech applications. The system introduces a mapping engine that sits between gesture recognition (via MediaPipe in Python) and sound generation (in Max/MSP). The engine will allow users to define how gestures control sound using deterministic mapping (rule-based), learned mappings (customizable, ML-based), and hybrid mappings combining the two. It will emphasize real-time performance, flexibility, user-friendliness, and reusability with mappings that can be saved/loaded as JSON files. This project will enable rapid prototyping of gesture-controlled musical instruments and other sound generation for creative as well as research-oriented objectives.

Problem: Brian2CUDA offers significant GPU acceleration for neural simulations, but its current "beta" state contains friction points that hinder widespread adoption. Key issues include unreliable Windows support due to POSIX-specific build assumptions, slow incremental compilation that often exceeds simulation time, silent GPU failures that are difficult to debug, and startup crashes related to preference file validation. Solution: This project aims to make Brian2CUDA "production-ready" by modernizing its backend infrastructure without adding heavy external dependencies. The plan involves: Stabilizing the Windows workflow by implementing a robust nmake/MSVC build path and platform-independent path handling. Optimizing compilation speed through deterministic source grouping and granular dependency tracking in generated Makefiles. Implementing a synchronized C++/Python logging system with structured CUDA error-checking to eliminate silent failures. Resolving preference validation conflicts to ensure reliable configuration loading. Deliverables: - A validated cross-platform build system supporting Windows (nmake) and Linux/macOS (Makefile). Optimized code-generation templates for faster incremental builds. A unified diagnostic logging framework. A suite of regression tests and "Getting Started" documentation for Windows users.

The project will develop the first version of an app that uses Bluetooth to connect with heart-rate and respiration sensors, calculate metrics of synchronization and variability based on these measurements and implement a biofeedback protocol to control this variability. This will allow the study of autonomic nervous function, and will allow biofeedback protocols for mood and health intervention to be implemented via live tracking of breathing and heart-rate. I plan to use the available open source code which is in python and re-write the modules in dart using the pub dev packages.

Traditionally, brain activity has been analyzed independently from peripheral physiological measurements like the electrocardiogram (ECG), but our understanding of brain-heart interactions (BHI) has significantly evolved since then: we now know that not only does the brain modulate the heart but surprisingly the heart exerts a powerful influence on the brain. For example, the timing of a learning task relative to the cycle of the heartbeat modulates its event-related potential (ERP), and heart-beats interact with activity in the insula, an area critically involved in internal monitoring. However, despite this increased interest in BHI in the neuroscientific community, there is a lack of well-documented tool, that incorporates much of the modern BHI identification techniques, treats sensitively ECG artifacts, and furthermore complements modern brain connectivity analysis. BHI studies point to a much greater complexity in neural signals that current connectivity packages fail to account for, such as recent work pointing to the modulating of brain oscillations by respiration. As such, this project has two main purposes: extract BHI and direct respiratory modulation of the brain and build a brain connectivity tool that accounts for these confounding measures, built in the Python MNE environment to complement traditional data analysis pipelines. Our analysis functions will furthermore be validated through tutorial-like experiments, written as Jupyter notebooks on open datasets, and we hope that the results I show will convince the scientific audience of the importance of confounding peripheral measures in neural data. The minimal set of deliverables include: individual analysis functions for peripheral physiological signals, connectivity measures between peripheral and neural signals, and brain connectivity measures, both regular, and conditioned on peripheral physiological signals to remove their effect, and experiments demonstrating these tools on open datasets.

The Virtual Brain (TVB) is a brain stimulation platform. It offers tools for computing, simulating and analyzing functional and structural data of human brains. TVB provides a graphical user interface (GUI) for using its tools for studying human brains. The platform supports importing data into TVB like projects, data structures etc. Since TVB provides various tools for studying human brains the platform is also accessible through REST APIs. Goal of this project is to create a new package which will consume TVB REST services and perform operations on it. The new python client will have features like uploading data into a TVB, data encryption and validation, BIDS compatibility check etc. Users will be able to use this python client to interact with a remote TVB server without using an active GUI.

Conducting Cognitive Neuroscience Experiments has always been limited to research-grade EEG devices that cost tens of thousands of dollars. Since the conception of cheaper alternatives like MUSE, OpenBCI, etc - there have been an influx of consumer grade EEGs that allow the general public to have access to such devices. However, there is a lack of a standard and easy to use library to conduct and reproduce research on these devices. EEG - Notebooks provides the necessary software required to pull together the various enabling technologies necessary for running these experiments and analyzing the data. This can open dramatic new possibilities for both neurotech and cognitive neuroscience education, as well as more ambitious and large-scale research and clinical applications using large numbers of devices and or more naturalistic (out-of lab) settings. This leads towards the larger goal of contributing to the democratization of the cognitive neuroscience experimental world. In its current state, the source code for the EEG-Notebooks experiment library is limited by its overly repeated and non-generalized code. This project seeks to tackle that issue by using classes and Inheritance to make the code easier to read, more extendable to the open source community, and a better experience for the general user. This will be instrumental in helping EEG-Notebooks move forward towards its goal of being the de-facto library for reproducing Cognitive Neuroscience Experiments on consumer-grade EEGs.

The Medical Informatics Platform (MIP) currently lacks standardized automated governance for its federated infrastructure, leading to deployment friction and configuration drift. I plan to solve this by implementing a vendor-neutral CI/CD pipeline in GitHub Actions that automates Infrastructure-as-Code (IaC) validation and maturity assessment using the OWASP DSOMM framework. Key deliverables include a detailed DSOMM based infrastructure audit, an automated orchestration pipeline featuring IaC scanning and SBOM generation, and a reusable secure pipeline blueprint to enable scalable and reliable infrastructure management across the EBRAINS community.

This project aims to build HarmonyHub, a web platform for personalized and engaging learning experiences with variable-pitch instruments like wind instruments (e.g., Trumpet, Flute, Clarinet) and bowed string instruments (e.g., Violin, Viola). Most wind and string instruments are among the most difficult instruments to master. This project seeks to bridge the gap between traditional music education and modern technological capabilities. The website offers customized exercises based on a student's skill level and desired progression speed, with real-time feedback for improvement. Personalized features, such as adapting exercises to master different rhythms with precise control over intonation, loudness, pitch, etc., will be implemented. Students and teachers will be provided with features to input any score, and the website will analyze the score, play the sound, and demonstrate how to play it on the instrument with pictures for the students to understand and replicate. When the students play it, real-time feedback of their performance will be provided. All of this is done through proper API integrations of APIs available for this process.

The project aims to refactor the Brain's unit system into a standalone package. Additionally, it aims to incorporate additional functionalities from other unit packages such as astropi (for type annotations), pint (for integration with matplotlib’s unit system), Quantiphy (for string formatting), and pint-pandas (for integration with pandas). To achieve the desired outcome, I propose structuring the standalone package into multiple submodules, each well-documented with READMEs and examples. Moreover, the package will include new units, constants, and potentially implementation of tests for other projects. This approach will enable other organizations and developers to easily utilize the resulting Brain unit package in their projects. The integration into other projects will be seamless and effortless due to the well-structured documentation and package stability. This will ensure widespread adoption of the Brain unit package in scientific research projects, thereby making a significant impact on the computational and development communities.