Explore Projects

<p>Javis.jl is a graphical animation/visualization package for the Julia Language which fetches motivation from Grant Sanderson's Python based animation engine viz Manim. This proposal aims to bring a more organized experience for creators and developers via layers, powerful abstractions for improved syntactic sugar, aesthetically pleasing animation tools and the ability to livestream animations.</p>

Dagger.jl currently serializes all GPU tasks onto a single stream per device, leaving independent DAG branches unable to run concurrently and GPU hardware severely underutilized. This project implements multi-stream execution for the CUDA and ROCm backends by replacing the single fixed stream with a per-device stream pool, integrating stream-aware scheduling into the task dispatch layer, and replacing the global device barrier with event-based synchronization. The expected outcome is a significant reduction in end-to-end latency, improved Streaming Multiprocessor occupancy, and meaningful overlap between memory transfers and kernel execution.

KomaMRI.jl is a high-performance Julia package for MRI simulation and differentiable workflows, but its use is currently limited to the Julia ecosystem, creating a barrier for the broader Python-based scientific computing and machine learning community. This project introduces komamripy, a lightweight Python wrapper that exposes KomaMRI’s core simulation and differentiable capabilities through a minimal, intuitive API. The approach leverages Julia–Python interoperability to map data structures between environments, incorporates Julia-side precompilation to reduce first-use latency, and enables flexible GPU backend support across CUDA, AMDGPU, Metal, and oneAPI. The project will deliver a pip-installable Python package with CI-tested builds and automated releases, precompiled simulation and autodiff workflows, cross-platform GPU backend selection, and a validated end-to-end example demonstrating differentiable RF pulse optimization using JAX, along with supporting documentation and example scripts.

<p>Differential equations are widely used in any scientific field. A new method of solving differential equations using deep learning methods has great prospects and have greater versatility over the grid numerical methods. Neural networks can be used as a method for efficiently solving difficult partial differential equations(PDEs). The library that provides the method for solving a general form of PDEs using deep learning will be a useful tool for many scientists and engineers, as well as students.</p> <p>This project aims to design of a general solver for different types of PDEs using deep learning approach base on the <a href="https://arxiv.org/abs/1907.04502" title="PINNs" target="_blank">PINNs</a> algorithm as part of <a href="https://github.com/SciML/NeuralPDE.jl" title="NeuralPDE" target="_blank">NeuralPDE.jl</a> library using the <a href="https://github.com/JuliaDiffEq/ModelingToolkit.jl" title="ModelingToolkit" target="_blank">ModelingToolkit.jl</a> PDE interface.</p>

<p>DifferentialEquations.jl comprises of leading-edge methods for solving Differential Equations and an extensive benchmark suite written purely in Julia. Many methods have state-of-the-art performances, but still, some of them can be accelerated for high-performance returns. This project aims to maintain the same standards and improve benchmark performances of various solvers. In essence, the project will emphasize increasing the speed through iterative optimizations, bug fixes and improvements, reduce redundant memory allocation and improved benchmarking.</p>

<p>Escape analysis is a classic problem in compiler analysis. Julia compiler has an existing AbstractInterpreter framework for managing inter-procedural analysis of type through data-flow analysis. But the existing framework has very limited support for escape information.</p> <p>In this project, we are implementing escape analysis via extending the current framework or via implementing a new framework and integrating it into the compiler. With better escape information collected, we are able do more kinds of optimizations including converting heap objects to stack objects and scalar optimizations.</p>

<p>This proposal is about implementing HTTP/2 for HTTPServer.jl and Requests.jl, as well as implementing a heuristic for Mux.jl for HTTP/2’s “server push”. In the end, It is expected that Mux.jl, HTTPServer.jl and Request.jl users can seamlessly transit to HTTP/2 with little changes on their sides.</p> <p>Here are some expected outcomes of this project.</p> <ol> <li>A new, unified version of the HTTPServer module and Requests module for both HTTP/1.1 and HTTP/2. The API "disables" certain methods and options for a HTTP/1.1 connection.</li> <li>Extensions such as Alternative Services and Opportunistic TLS will be implemented in HTTPServer.jl and Requests.jl.</li> <li>Specifically for HTTPServer.jl, expose a nice “server push” API that allows other libraries to specify what other resources to push along with the requested resources.</li> <li>In Mux.jl, build a middleware for HTML and CSS to extract resources to be “server pushed”. Good documentation and tests for those middlewares.</li> </ol>

The main aim of this project is to expand the capabilities of Attractors.jl. We are specifically targeting three features, which are the Minimal Fatal Shock Algorithm, Automatic Attractor Characterization, and Optimizations of the recurrence algorithm. To be more specific, these three features encompass the following aspects: a novel algorithm for predicting the behavior of arbitrary systems under critical conditions, optimization, and improvement and optimization of the existing algorithms to expand their functionality and cover the weak points. We are confident that incorporating these new features will result in substantial improvements of the Attractors.jl library and will be highly valued by the nonlinear dynamics community in Julia.

<p>The IterativeSolvers.jl package is currently lacking some well-known iterative methods such as QMR and BiCGStab(l) for solving <em>linear systems</em> and IRAM and Jacobi-Davidson for <em>eigenvalue problems</em>. The first two methods are probably the last low-hanging fruit type of algorithms, while the latter two are quite specialized.</p> <p>Implementing Jacobi-Davidson and IRAM is important, since currently Lanczos is the only eigensolver available, which applies to hermitian matrices only. Jacobi-Davidson and IRAM are quite subtle to implement correctly and efficiently (they require specialized restarts for instance), which probably explains why they are currently not yet available.</p> <p>A benefit of having implicit restart available is that it can improve restarted GMRES as well.</p>

FlashFill is a program synthesis framework for generating string-processing programs from input-output examples. This project aims to implement FlashFill in Julia and integrate it with DataFrames.jl. Such a package would be a valuable tool for Julia users handling tabular data, providing an easy way for data-cleaning and data-wrangling. It would also lay the foundations for implementations of further open-source program synthesis frameworks in Julia.

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.

This project extends Dagger.jl with an MPI-based backend, allowing it to scale more effectively on high-performance computing (HPC) clusters that use low-latency interconnects like Infiniband or HPE Slingshot. Dagger already offers a productive way to express parallelism in Julia, using Directed Acyclic Graphs (DAGs) to schedule and run tasks. However, it currently relies on Julia’s Distributed.jl and TCP for communication, which becomes a bottleneck at large scales. In the exaflop era, where extreme-scale simulations demand both scalability and productivity, this limitation is significant. By integrating MPI, we build on vendor-optimized communication libraries to combine Dagger’s ease of use with the performance needed in HPC environments, much like frameworks such as Legion and Iris.

As a part of this project, I will be working with JuliaHealth to develop the OMOPCDMPathways package for health and medical data analysis. The package will include features such as selecting treatments of interest, finding treatment history of patients, combining overlapping events, filtering treatments for repeated occurrences, and examining drug refills. And as a part of stretch goals I also aim to integrate with the JuliaStats ecosystem and create novel visualizations for treatment pathways. My project timeline is designed for a structured and comprehensive development process. I'll begin by setting up my development environment and database connections, then move on to selecting treatments of interest and preparing the database. Following that, I'll work on filtering treatments for repeated cohorts, developing the treatment history of patients, handling drug refills, and era collapse, with each task having its own dedicated time for development and testing.

<p>Support parallelism in Bio.jl based on Dagger.jl</p>

<p>I propose to</p> <ol> <li><p>Add a package for image segmentation as a part of JuliaImages with the following algorithms</p> <pre><code> * Thresholding - Otsu’s method and Adaptive thresholding * K-means clustering * Mean shift segmentation * Watershed segmentation * Felzenszwalb's efficient region merging algorithm * Shi and Malik’s normalized graph-cut based segmentation </code></pre> </li> <li><p>Add Histogram of Oriented Gradient feature to ImageFeatures.jl</p> </li> </ol>

My proposal is to bring in core changes to Javis' Object - Action mechanism for making animations . As of now Javis does not store drawing information as a data-structure but a function at compute time. The Object is drawn to the canvas by a function call at render time. The proposal has 3 parts. First - pre-compute the polygons/paths that an Object will place on the canvas, and have that information as a field in the Object. This part involves hacking into functions in Luxor.jl to store/return the information of drawn paths somewhere. Second - Bring in the ability to partially draw an object with the above paths at hand. Also implement functions to animate the "creation" of the object being shown. For example if the Object were a circle , the creation animation would draw an arc increasing its angle from 0 to 2Pi . Third - Bring in the ability to morph an Object into another. For example turn a square into a circle. The current implementation of Morphing in Javis has certain limitations, with the proposal implemented any arbitrary Object would be morph-able into another Object

Graph Neural Networks (GNNs) rely on message passing, traditionally implemented via a gather/scatter mechanism. In GraphNeuralNetworks.jl, this approach materializes dense feature matrices on graph edges, leading to severe memory bottlenecks and reduced performance as graph sizes scale. This project addresses this limitation by redefining message passing as non-materializing Sparse Matrix-Matrix Multiplications (SpMM). By treating the graph as a sparse mathematical operator, this project will unlock significant computational efficiency and memory savings on CUDA GPUs. The core objectives include integrating COO storage, upstreaming patches to CUDA.jl, and refactoring the GNNlib API. To ensure continuous momentum during upstream review cycles, the project features a secondary track focused on upgrading the Automatic Differentiation (AD) pipeline by fully integrating Mooncake.jl and Enzyme.jl, alongside expanding the ecosystem with new datasets and new tutorials / improved documentation.

This project adds a new package to JuliaStats, covering complex survey analysis. The package is inspired by the `survey` package in R. Specifically, a part of the R package is ported to Julia. The completed project will consist of added support for survey analysis, along with the associated documentation.

MedEye3D.jl aims to enhance medical imaging visualization within the Julia language ecosystem. The current proposal addresses the need for improved functionality in windowing, support for the display of super voxels, faster load times, and robust viewing of multiple images. By leveraging Rocket.jl and ModernGL.jl, the proposal plans to implement features like enhanced windowing for MRI and PET data, support for the display of super voxels, and high-level functions for improved user experience. The project aims to streamline visualization processes and provide essential tools for 3D medical imaging workflows. The main deliverables include: Supporting simultaneous visualization of multiple registered medical images, with linked scrolling, cursor highlighting, and connecting lines between annotated points across images. Implementing automatic windowing and colormaps for common MRI and PET imaging modalities to provide consistent visualizations mimicking other medical imaging software. Adding support for visualizing supervoxel segmentations with boundary detection using techniques like the Sobel filter. Improving startup time by precompiling critical components of the package. Implementing high-level functions to simplify basic usage by abstracting away low-level details of image loading, rendering, and visualization. By enhancing MedEye3D.jl with these features, the project aims to provide a more comprehensive and user-friendly tool for 3D medical image visualization and analysis within the Julia ecosystem. The improvements will facilitate better integration into medical imaging workflows and enable more efficient exploration and interpretation of data across different modalities.

In March 2016, AlphaGo became the first computer Go program to beat one of the best go players in the world. But Deepmind didn’t stop there and kept developing better versions of it, namely: AlphaGo Zero, AlphaZero, and MuZero. AlphaZero.jl is an open-source implementation of one of those and became a great showcase of Julia’s unique strengths. And it is the 8th most starred Julia package. This Google Summer of Codes aims to add on top of AlphaZero, the MuZero implementation into AlphaZero.jl and create an interactive and pedagogical website that not only explains the MuZero algorithm but also illustrates deeper explanations of its hyperparameter tuning and implementation tradeoffs. This GSoC will not only expand a great Julia package but also give more visibility and illustrate Julia’s advantages in Machine Learning projects.

GPU computing provides substantial performance gains over CPU-based methods for computationally demanding tasks. Trixi.jl, a Julia numerical simulation framework for hyperbolic conservation laws, currently lacks native GPU support. This project aims to accelerate PDE discretization in Trixi.jl using GPUs via CUDA. Key subtasks include developing a simple 1D CPU code, extending it to 2D and 3D, porting it to GPUs, prototyping GPU implementations of existing Trixi.jl kernels, optimizing data transfer, and expanding GPU support for more complex methods and GPU types. The final deliverable will offer high-performance PDE solvers on GPUs, showcasing the benefits of GPU acceleration in Trixi.jl.

This project aims to extend the existing capabilities of ReachabilityAnalysis.jl with a new state-of-the-art algorithm for reachability analysis, based on recent literature. The algorithm will improve the precision of reachable set computations for systems with uncertain parameters, utilizing matrix zonotopes—a set representation that provides tighter enclosures than traditional convex sets. Building on recent research, I will develop a new Julia package, MatrixZonotopes.jl, which will provide the necessary operations for working with matrix zonotopes and integrate it into the JuliaReach ecosystem. Based on the functionalities added by the new package, a reachability algorithm for linear systems will be implemented. At the end of the project, the new package will be available, along with the reachability algorithm, and a blog post will document their performance and functionalities.

<p>JuliaDiffEq is the most popular github organization for solving differential equations in Julia.Currently, it has an assorted collection of Ordinary Differential Equations (ODE), StochasticDifferential Equations (SDE) and Algebraic Differential Equations (DAE) solvers.</p> <p>But currently, there is no support for Partial Differential Equations (PDEs) which form an integral class of Differential equations found ubiquitously in natural sciences and engineering. PDEs are generally solved approximately by discretizing them to form ODEs which can then be solved separately.</p> <p>A toolbox to solve a large family of scientifically-interesting PDEs is thus sought. In light of this, I propose to create a toolbox of methods for discretizing PDEs in Julia.</p>