The Julia Language

Mentors: Student: Kareem Fareed

Advanced magnetic resonance imaging techniques, such as RF pulse optimization, increasingly rely on complex, high-performance physical simulations like those defined in KomaMRI.jl. Currently, integrating these simulations into optimization loops is bottlenecked by the lack of native gradient propagation. This project aims to unlock gradient-based optimization within the Koma ecosystem by enabling reverse-mode automatic differentiation (AD) as a first-class feature. By systematically integrating state-of-the-art AD tools, specifically Enzyme.jl and Reactant.jl, this project will make both the standard BlochSimple method and the highly optimized, custom Bloch GPU kernels fully differentiable. Core deliverables include establishing AD correctness baselines against FiniteDifferences.jl, designing a memory-efficient Simulation data structure to minimize device-host transfers, and resolving low-level upstream compatibility issues with CUDA.jl and Enzyme. Ultimately, this project will provide the Julia MRI community with a robust, fully differentiable simulation stack, culminating in an interactive tutorial for 1D RF pulse optimization.

Mentors: Student: Parv Mittal

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.

Mentors: Student: Shahu Karale

My main goal this summer is to make Adaptive Mesh Refinement (AMR) fast and efficient for P4estMesh on GPUs within Trixi.jl. Right now, whenever the mesh adapts dynamically, it triggers repeated memory allocations on the device. This creates a severe host-device synchronization bottleneck that kills performance, despite the excellent hardware support we have via KernelAbstractions.jl. To solve this, I will build an allocation-free memory manager. By implementing a multi-pool arena specifically designed to match Trixi's Struct-of-Arrays (SoA) layout, I aim to eliminate these driver-level stalls. My final deliverables include a fully functional, type-stable GPU AMR pipeline and comprehensive performance benchmarks across both NVIDIA and AMD hardware

Mentors: Student: Bhavya-QuantDeveloper

Julia's medical imaging stack currently relies on 3D U-Net variants for segmentation, which lose spatial relationships through max-pooling. This project implements 3D capsule network architectures in Lux.jl that preserve part-whole spatial hierarchies through dynamic routing-by-agreement. I will build reusable capsule layer primitives (PrimaryCapsule3D, ConvCapsule3D, routing modules), two full architectures (3D SegCaps and a SegCaps-UNet hybrid), and custom GPU-accelerated routing kernels using KernelAbstractions.jl. The full pipeline integrates with MedPipe3D.jl for data loading, training, and evaluation. Deliverables: (1) Capsule layer primitives as Lux.jl modules, (2) 3D SegCaps architecture, (3) SegCaps-UNet hybrid, (4) GPU routing kernels, (5) training pipeline with MedPipe3D.jl, (6) benchmarks across all 10 Medical Segmentation Decathlon tasks (Dice, HD95, cross-task transfer vs 3D U-Net), (7) documentation and pretrained weights, (8) PRs to JuliaHealth.

Mentors: Student: Victor Camara

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.