Explore Projects

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.

<p>The random number generator(RNG) of Julia needs updating to a more reliable one. I'm going to implement a package (may be named RNG.jl) providing several RNGs, and a binding to Intel MKL(VSL.jl) for the RNG work. After comparing the performance of them the best one is supposed to replace the current RNG in Julia Base.</p>

QuantumClifford.jl is a package designed for simulating Quantum Clifford circuits, circuits that consist of Clifford gates. QuantumClifford.jl can be highly useful for designing Quantum error-correcting codes. Since applying Clifford gates to Stabilizer states is mathematically similar to Linear Algebraic operations, we can utilize GPU to parallelize the process and make it significantly faster. This Summer of Code project consists of implementing the aforementioned Clifford gate operations in GPU kernels, and then seamlessly integrating them into the rest of the QuantumClifford library.

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.

<p>Polychord is a nested sampling algorithm which is designed to sample from high-dimensional parameter spaces. Slice sampling is used at each iteration to sample within the likelihood constraint of nested sampling. Polychord is capable of identifying various modes of the posterior. This project aims to construct a polychord nested sampling algorithm in Julia. The final integration will be built into Turing.</p>

<p>The goal of this project would be to implement a fast open-addressed hash table inspired from Google’s <code>flat_hash_map</code>. In addition to this, I propose to work on getting an ordered version of hash tables, based on <code>OrderedDict</code>. All of these would be supplemented with proper benchmarks. Finally, I plan to work on getting several tree-based data-structures implemented and adding it to <code>DataStructures.jl</code>.</p>

<p>Interactive data exploration is an increasingly important component of data science. Interact.jl and Escher.jl are good libraries that have the potential to be extremely powerful for these tasks, but currently Interact only supports IJulia and Escher suffers some stability issues. WebIO.jl looks to be a promising path forward for building web based components that are created by or interface with Julia. Rebuilding Interact.jl on top of WebIO.jl will bring Interact beyond IJulia, to the Atom/Juno IDE and to desktop apps with Electron/Blink.jl. Additionally it should enable Escher.jl to reuse much of Interact, which will likely reduce Escher’s size and complexity significantly, increasing its stability. Furthermore, by removing its dependence on Jupyter and IPywidgets, Interact will gain flexibility to produce more complex UIs which intermix displayed data such as plots, and UI controls. Finally, I plan to add some automated UI testing which hopefully will assist in improving the stability of not just Interact and Escher, but potentially IJulia, Juno, and Blink as well.</p>

<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>My Proposal is to develop a feature detection and extraction package for Julia, ImageFeatures.jl. Alongwith feature detection and extraction, I will work on adding exposure correcting functions to <a href="https://github.com/timholy/Images.jl" target="_blank">Images.jl</a>. I plan to add the following functions over the course of the coding period :</p> <ul> <li>BRISK Descriptors</li> <li>FREAK Descriptors</li> <li>ORB Descriptors</li> <li>GLCM</li> <li>LBP</li> <li>BRIEF Descriptor</li> <li>CENSURE Keypoint Detector</li> <li>FAST Keypoint Detector</li> <li>Histogram Matching</li> <li>Histogram Equalisation</li> <li>Gamma Correction</li> <li>CLAHE Algorithm</li> </ul>

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>ODE.jl is an ever increasing store house of numerical solvers of ordinary differential equations. While many solvers are currently found in ODE.jl, there are still many which are awaiting a native Julia implementation in the package. In particular, there is a lack of implicit solvers implemented in ODE.jl (currently, there is only one implicit solver: ode23s). Such solvers are important because they are especially suited for solving stiff ODEs, which are very common. In light of this, the first goal of my proposed project is a native implementation of implicit solvers RADAU and MEBDFI. Further, in order to reliably use ODE.jl, a robust initial value problem (IVP) testing suite for ODE.jl solvers is a necessity. Work has has been started towards this end through the development of IVPTestSuite.jl. Though, there are many improvements to IVPTestSuite.jl which could be made, especially in improving the ODE solver performance tracking. Thus, the second goal of my proposed project is to advance IVPTestSuite.jl and its surrounding documentation.</p>

This project addresses the challenge of unreliable LLM outputs in complex health informatics workflows by building a domain-grounded Retrieval-Augmented Generation (RAG) system within JuliaHealth. It enables users to convert natural language queries into accurate, executable FunSQL.jl workflows by grounding responses in curated resources like OMOP and OHDSI. The project will deliver a modular baseline RAG pipeline, a reproducible evaluation framework to benchmark query quality, and clear documentation with an end-to-end demonstration for usability and future extension.

QuantumClifford.jl enables efficient simulation of Clifford circuits acting on stabilizer states using the (de)stabilizer formalism, with complexity O(𝑛²), where 𝑛 is the number of qubits. For sparse stabilizer states—those with a qubit connectivity of O(log 𝑛)—an alternative algorithm based on graph states achieves improved complexity of O(𝑛 log 𝑛). This project aims to implement this graph-states-based simulator as an alternative backend in `QuantumClifford.jl`. Specifically, the project will: support the simulation of generator gates {𝐻, 𝑆, Λ𝑍}, enable the decomposition of arbitrary Clifford gates into these three generators, and implement single-qubit Pauli measurements on graph states. The goal is to provide a seamless transition to the graph-based simulator through compatibility with existing `apply!` and `project!` APIs in `QuantumClifford.jl`.

The Language Server Protocol (LSP) is a communication protocol between editors and analysis engines. Many major editors support this protocol, making Language Servers—development support tools that communicate with editors via LSP—highly significant in modern development environments. In this proposal, I aim to implement and enhance some new features for a new Language Server called JETLS, which is deeply integrated with the latest Julia compiler infrastructure. I will strive to deliver low-latency, precisely source-mapped feedback to users, enhancing the overall development experience by leveraging JET.jl, Revise.jl, JuliaSyntax.jl, and JuliaLowering.jl. JETLS will provide powerful editor support for programmers working on large-scale Julia codebases, helping them discover potential bugs and write more efficient code.

<p>Differentiable Programming is a programming paradigm in which we can differentiate through the program itself. It allows us to exploit the knowledge already embedded in a problem and use existing deep learning techniques to it. This project aims to develop a Ray Tracer in Julia and interface it with Flux/Zygote for Automatic Differentiation support. Also we shall demonstrate the use of this Ray Tracer in downstream Reinforcement Learning Tasks.</p>

<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>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 David-Skene algorithms are a family of computational methods for aggregating crowdsourced annotations of data in order to obtain the true labels or categories for that data, which is very useful in places where we do not have access to the "true" annotations for large datasets and therefore need to rely on fallible human judgment. The most traditional version of the David-Skene (DS) algorithm dates back to 1979 but more recently a more efficient (eightfold sppedup) although less accurate version, called Fast David-Skene (FDS) has been developed. The hybrid variant (HDS) sits in the middle in terms of accuracy and speed between DS and FDS. Since demands for the two differ according to situation, it makes sense to implement all thre versions (DS, FDS, and HDS) so that everyone interested can use the one most suitable to their situation. This is the purspose of this project. Additionally, the algorithms in question will be extended to be applied to multi-label problems as well.

<p><a href="http://zxcalculus.com" target="_blank">ZX-calculus</a> is a graphical language that can characterize quantum circuits. It is a powerful tool that is usually used for quantum circuit simplification. <code>ZXCalculus.jl</code> will implement quantum circuit simplification algorithms based on ZX-calculus in pure Julia. Also, it will provide interfaces to import and export quantum circuits to the form of YaoIR, an intermediate representation for quantum programs in the <a href="https://github.com/QuantumBFS/Yao.jl" target="_blank"><code>Yao.jl</code></a>. So that one can get quantum circuits with higher performance automatically when designing quantum programs with <code>Yao.jl</code>.</p>

<p>Julia language offers support for differentiable programming with the help of its AD. This projects leverages this to test differentiable programming (DP) approach for autonomous vehicle research. Goal of the project is to create a duckietown environment in julia and have it trained with DP algorithms on various maps.</p>

The state of Julia GPU support ranges from “very good” (CUDA.jl) to “on the way” (Metal.jl). Recently, the shared high-level interface GPUArrays.jl added support for KernelAbstractions.jl, which defines a common interface that can be used to write optimized kernel implementations once for all the downstream vendor-specific GPU packages such as CUDA.jl, AMDGPU.jl, Metal.jl, and oneAPI.jl. However, most optimized kernel implementations still live in the vendor-specific package they were written for, leaving the other packages to either reimplement their own version, use the current unoptimized fallback implementation from GPUArrays.jl, or in many cases, the operation is not supported. This project aims to rewrite these optimized operations in GPUArrays.jl using the KernelAbstractions interface to improve performance and functionality for all GPU backends at once. The end result being that users of the less mature backends will benefit from more functionality, as well as increasing the impact of future contributions for all users of the JuliaGPU ecosystem.

Traditionally if a user asks a question to an LLM about a package then, the response might be incorrect, or outdated. The project "Supercharging the Knowledge Base of AIHelpMe.jl" is about extending AIHelpMe’s knowledge base and build a RAG system to include the latest information about its documentation and to increase the accuracy of LLM’s response. Incorporating comprehensive, up-to-date Julia’s resources into the AI’s knowledge base will benefit Julia developers, programmers, AI and ML enthusiasts, or any programmer to get more accurate responses, clear doubts and solve bugs.

<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>