Explore Projects

Classical force fields in molecular dynamics are fast but cannot capture bond breaking, charge transfer, or complex many-body chemistry. Machine learning potentials (MLPs) close this gap — offering near-quantum accuracy at a fraction of ab initio cost. Molly.jl currently supports MLPs only through a Python bridge (ASECalculator), which requires a Python runtime and bypasses Julia's differentiable programming stack entirely. This project delivers native Julia support for four widely-used MLP families: ANI (neural network potential for organic molecules), ACE (linear body-ordered basis expansion), NequIP, and Allegro (E(3)-equivariant graph neural networks). ANI is implemented from scratch in pure Julia using Lux.jl, with pre-trained ANI-1x/ANI-2x weights loaded from HDF5. ACE is integrated via the mature ACEpotentials.jl package. NequIP and Allegro are wrapped from TorchScript-exported models via PythonCall, following the existing ASECalculator pattern. All four potentials plug into Molly.jl's general_inters dispatch loop with zero changes to core simulation code. Pure-Julia models (ANI, ACE) are fully differentiable via Enzyme reverse-mode AD and GPU-accelerated via KernelAbstractions. The result: researchers can run differentiable, ML-accelerated molecular dynamics entirely within Julia — no Python, no overhead, composable with the full SciML ecosystem.

<p>LoopSim framework aims to facilitate workflows with loops i.e workflows without specific start and end services. LoopSim requires an interface to create these types of workflows using some kind of graph.<br> It currently relies on a Closed Source software yEd - Graph Editor for workflow creation. The objective of this project is to remove this dependency on a closed source software and build an open-source solution tailored for LoopSim requirements.</p> <p>We also need to integrate this project with the existing parser so as to automate the flow from running the script and building the workflow to parsing it. The proposed solution will make it easier to web host the LoopSim project.</p>

LLM4S is building a Scala-native AI toolkit that leverages functional programming principles and strict compile-time checks to ensure the reliability and maintainability of LLM-powered applications. This project aims to extend the initial agentic loop and implement essential tools, empowering Scala developers to build robust, reliable, and explainable AI solutions. Key objectives include implementing a robust agentic loop, integrating MCP for dynamic tool interaction, developing core tools for file systems, ensuring context management, testing frameworks, and comprehensive documentation to support reliable LLM-powered applications.

This project is proposed to 1. Prevent the loss in details happening when the user edits, uses the crop/rotate feature when uploading images through the Wikimedia Commons app by replacing LLJTran with JPEGTran which handles details gracefully. 2. Implement Lossless Block-Level Blur The Blur feature at present makes quality loss of image in the process. This is solved by recompression to only relevant blur required pixel blocks then untouched areas wont have loss in details. 3. Auto-detect and blur faces & car number plates. When the user uploads images there is less privacy for random people and car number plates captured by user in the photo use OpenCV to detect faces/plates and apply blur to only region which OpenCV specifies

<p>In this proposal, the governing equations and boundary conditions of the plug flow reactor with surface chemistry are discussed (Details see Section 2). The coding part will start with the simple boundary condition (pressure constant, adiabatic, etc.). SUNDIALS IDA solver for differential-algebraic equations will be employed to solve the governing equations, further research will be done on the coding part. Timeline is also neatly showed in Section 3, and previous related projects and courses are listed in Section 4. The reasons for the project choosing are also listed in Section 5.</p>

Implement 3D tetrahedral adaptive remeshing routines for spacecraft heat-shield reentry thermal simulations.

<p>The problem of population genetics can be viewed as a stochastic process. The aim of the project is to understand the reverse transition dynamics of the system conditioned on the end position. In order to understand the feasibility of using reinforcement learning to the problem, agents are tested against stochastic processes that resemble population genetics. Practical evidence is validated to provide a sanity check on the feasibility of deployment of such a method in practice in large-scale problems of population genetics.</p>

<p>Brian simulator becomes more and more popular in neuroscience community. At the same time Python is now some kind of state-of-the-art in the field, so it is crucial to have big set of tools helping scientists to work in that environment. Functionality of Brian grows up every year and as a recent user of that module who found it very useful I would like to contribute and just help developing the tool.</p>

Package dingo is a python package that analyzes metabolic networks. It relies on high dimensional sampling with Markov Chain Monte Carlo (MCMC) methods and fast optimization methods to analyze the possible states of a metabolic network. It represents a metabolic network with a convex polytope, while the points in the interior of the polytope correspond to steady states of the network. By sampling, dingo, explores and statistically studies the flux space of the network. To perform MCMC sampling, dingo relies on the C++ library volesti. Currently, it provides MMCS algorithm which is based on Billiard Walk and on a multiphase rounding scheme. This project will provide dingo additional options for uniform sampling by exposing into it several C++ implementations of random walks that are included in volesti. Moreover, it will provide sampling from the exponential distribution using the C++ implementation of Hamiltonian Monte Carlo in volesti.

Perturbation biology datasets across CRISPR screens, MAVE, and scPerturb-seq remain siloed in incompatible formats, making cross-modal reasoning about genetic perturbations nearly impossible at scale. This project builds a perturbation-aware LLM by fine-tuning BioMedLM on a curated multimodal training corpus derived from the EMBL-EBI Perturbation Catalogue, enabling natural language queries such as "what happens if gene X is knocked out in cell type Y?" Deliverables include a multimodal training corpus, a fine-tuned LLM prototype, a reproducible evaluation pipeline with gene-level splits distinguishing genuine generalisation from memorisation, and full open-source documentation for reuse by the Perturbation Catalogue team.

Refactor HTTP transport layer to utilize native Node 18+ Web Standards Fetch API with automatic retry backoff.

The aim of this project is to make the currently running forecasting system capable of parallelization. This is needed because the forecasting system currently follows a sequential method to forecast, which could be further optimized in the terms of time it takes by using multiple cores both on individual machines and High Performance Computers (HPC). This would be achieved by applying a forked parallelization method on the embarrassingly parallel problem available within the project currently.

Provide developer-friendly TypeScript fluent builders for defining Atlas Vector Search indexes and cosine similarity aggregations.

<p>The SciUnit framework was developed to help researchers create unit tests for scientific models. Currently, unit tests exist for models of single neurons and small networks thereof. However, unit tests for models concerned with large-scale brain network dynamics, such as meso-scale, mean-field descriptions and corticothalamic circuit models have not been developed yet. During the summer, I plan to develop tests to validate predictions from a corticothalamic neural mass model against relevant features of EEG data.</p>

<p>Extending SciUnit model testing to bifurcation models of spin-glass-like neuron network. I would propose to use model parameter optimization based on bifurcation analysis. This would use computational tools based on the theory of nonlinear dynamical systems to generate maps of parameter space that indicate the location of bifurcations at which one type of model behavior transitions into another type. These models may use many unknown parameters and specific weights. We can construct a network by fixing the known parameters and train it on input and output to determine the unknown parameters. I believe a bifurcation analysis of this model would provide solutions for sets of states for a given set of parameters. The way we adjust parameters and weights we may analyze the computations of a neural system in how it generates ideas from the organization of a network. I hope creating an algorithm of bifurcation analysis would provide insight into features of neuronal dynamics like multistability, oscillations, and symmetry.</p>

Project synopsis / summary: This project is dedicated to developing a set of automated tools and processes for extracting useful neuronal experimental data from datasets provided by the Allen Brain Institute, and converting these data into parameters that can be used for neuronal modeling on the NetPyNE platform, for comparison with cortical regions already validated by NetPyNE. The project flow is divided into the following steps: Data Collection: Automatically extracts data from the Allen Cell Type Database for specific cell types in the visual cortex, including electrophysiological properties, morphological characteristics, and gene expression patterns. The Allen Institute provides a powerful API that allows users to programmatically access and retrieve data. First through data cleaning, and then through data crawling to obtain data that is difficult to access in the API. In addition, domain-specific language models will be fine-tuned or trained using Google's Gemini model for subsequent data acquisition. Parameter Conversion: Develop tools(scripts) or design large language model prompts to automatically convert extracted data into a parameter format understood by the NetPyNE, such as .hoc or .swc format. Identify how to set reasonable default values for missing data. Model construction: Use the converted parameters to construct neural network models of relevant brain regions in NetPyNE. This includes defining neuron types, neuron connectivity, and synaptic interactions between neurons. Run Simulation: Run a simulation of the model in NetPyNE to simulate the brain's response to a specific input stimulus. Compare Results: Compare the simulation results with actual biological experimental data to verify the accuracy of the model. Intended set of deliverables: Automated Data Collection Tool. Parameter Conversion Script. Simulation Run Framework. Result Validation Report. Documentation and User Guide.

This project aims to build a Julia package for probabilistic modeling based on static directed graphs. Specifically, we want to enable users to execute programs previously written in BUGS(Bayesian inference Using Gibbs Sampling) directly in Julia.

This project aims to replace Simulation-Based Inference (SBI) methods with Markov Chain Monte Carlo (MCMC) techniques for inference problems involving complex or intractable likelihood functions, such as those in Virtual Brain Inference (VBI). While SBI uses deep networks to approximate posterior distributions, it can introduce hard-to-control biases and limit interpretability. In contrast, MCMC provides a more principled Bayesian approach by directly sampling from the posterior. A key challenge in using MCMC methods like Hamiltonian Monte Carlo (HMC) and the No-U-Turn Sampler (NUTS) is their need for differentiable likelihoods, which are often unavailable in high-dimensional models like those for fMRI, EEG, or MEG data. This project addresses that issue by leveraging Automatic Differentiation (AD), which allows efficient gradient computation. Implemented in libraries like JAX, which enables fast, parallel computation on GPUs. The first goal is to translate existing Virtual Brain models - specifically the Montbrió model - into JAX. This model simulates brain dynamics and links simulated EEG BOLD dynamics to fMRI observations. Its parameters, currently estimated via SBI, will instead be inferred using MCMC for improved accuracy and scalability. Reparameterization strategies and hierarchical structures will be used to enhance MCMC performance and convergence. Deliverables include a JAX-based translation of the Montbrió model, implementation of MCMC-based inference, reparameterization strategies, benchmarking against SBI methods, and application to real neuroimaging data. The outcome will offer more robust tools for understanding neural dynamics and disorders, improving the accuracy and interpretability of brain models.

This project develops agent-accessible CLI tooling for the Julia Bayesian ecosystem, delivering three main components: DoodlePPL CLI for model validation, code generation, sampling, and diagnostics with structured JSON output, MCMCChains.js, a TypeScript npm library enabling MCMC diagnostics and visualizations in the browser and TuringCLI, a command-line interface for Turing.jl that provides machine-readable JSON outputs, with all three deliverables building upon and extending the GSoC 2025 work on DoodleBUGS.

This project proposes adding new features to Rimu.jl --- a Julia package that implements a random integrator for many-body quantum systems --- allowing it to read FCIDUMP files or directly use data from the ElemCo.jl package and construct a molecular Hamiltonian. This will provide users with the ability to obtain highly accurate data from quantum Monte Carlo simulations and exact diagonalisation for extensible models involving the electronic structure of molecules starting from readily available quantum chemistry data.

MedPipe3D is a Julia package that enables working on GPU-accelerated medical image segmentation. MedPipe3D aims to merge MedEye3D, MedEval3D, and MedImage into one coherent pipeline. The project includes developing: Augmentations for medical data, Invertible augmentations and support test time augmentations, Patch-based data loading with probabilistic oversampling, Calculate Median and Mean Spacing with resampling, Basic Post-processing operations, Structured configuration of all hyperparameters, Visualization of algorithm outputs, K-fold cross-validation functionality. Streamlining processes around libraries and increasing both model performance and user experience.

<p>DifferentialEquations is a Julia package for solving differential equations in a highly performant manner within an underlying unified user interface. Recently, new promising classes of high-order methods for the weak approximation of stochastic differential equations were introduced and those solvers are yet to be implemented in the library. On top of that, Julia currently lacks adjoint sensitivity methods for stochastic differential equations. Adding these tools to the broader ecosystem of DifferentialEquations will attract researchers that seek to simulate (or even control) the dynamics as generated by stochastic differential equations. Possible fields of application range from the simulation of (bio-)chemical processes over financial modeling to quantum mechanics.</p>

Working with the OMOP CDM (Observational Medical Outcomes Partnership Common Data Model) involves handling large datasets that require a set of tools for extracting the necessary data efficiently. The first part of the project focuses on improving JuliaHealth's infrastructure by increasing the range of tools available to users. This involves enabling connections to various databases, and working with observational health data. Our second goal is to leverage the capacity built in the previous phase to develop a comprehensive framework for patient-level prediction. This framework will predict patient cohort outcomes with given treatments and will be tested on the mimic iii data, and potentially on real aggregated and anonymized patient data.