Explore Projects

This project aims to extend the Julia linear algebra ecosystem by developing vendor-agnostic GPU kernels in NextLA.jl for large-scale structured matrices. It focuses on tile low-rank (TLR) representations, which exploit low-rank structure to reduce computational cost and memory usage. The project will implement truncated SVD routines and core TLR arithmetic kernels, including low-rank GEMM, TRSM, and SYRK with adaptive truncation. These kernels will serve as building blocks for large distributed TLR algorithms, demonstrated through the implementation of a distributed TLR Cholesky factorization. By the end of the project, NextLA.jl will provide a portable, composable foundation for GPU-accelerated distributed linear algebra.

<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>Flux.jl is a high-level neural network library in Julia, which has an intuitive API, easy to debug, and performant. One of the key features of Flux.jl is that it allows user to define a layer in Julia, using most Julia Array operations, while not to worry about size inference, grad calculations, etc. Unlike Knet.jl, a promising competitor of Flux.jl, which do all the tensor calculations from scratch with a lot of magics, Flux.jl simply transcompile the computation graph to mature backends like MXNet and TensorFlow. Thus, it can take the benefits of those advanced technologies and get a cutting-edge performance.</p> <p>Flux.jl is in alpha and lacks a lot of features before being actually useful. One of the problems is currently it only supports SGD optimizer without decay and momentum. It also only shows the progress during training, while saving checkpoints or doing custom evaluations once a while can help users to build a better model.</p> <p>After this program finished, Flux.jl will be able to:</p> <ul> <li>train a model with most popular optimizers like Adagrad, Adam, etc.</li> <li>hook functions at specific time point, such as after every 100 batches</li> </ul>

Implementation of algebraic simplification to reduce expression to canonical form. Low level rules are be hard coded for improved performance and higher level rules based on pattern matching. Algebraic solver to solve an equation or sets of equation by looping over a set of reversal rules until no further rules change the equation. The possibility of a Symbolic Integration Implementation based somewhat on Rubi Integration.

Density functional theory (DFT) is an established method to compute the electronic structure of matter, with applications ranging from the development of catalysts to the discovery of new drugs. DFT finds an approximation of the Schrödinger equation corresponding to the studied system: this approximation comes to solving coupled non-linear partial differential equations. To deal with this method of simulation, the DFTK package is being developed in Julia. To reduce runtime, we wish to develop the use of a local GPU to offload computations. However, the goal is to minimize the amount of code which needs to be adapted: having two different versions of the code existing at the same time (one for CPU and one for GPU) can be difficult to maintain in an open-source framework. This also makes the implementation of new algorithms difficult, and can deter newcomers from getting involved in the project. Since GPU algorithms for DFT already exist, the main challenge is to orchestrate the overall flow of data between CPU and GPU. We believe expanding the DFTK package will showcase the possibilities the Julia programming language offers and bring together many different communities involved in molecular simulation. I aim to produce an alternate version of code of the DFTK package using GPU framework by clearly highlighting the differences with the CPU version and keeping code changes as low as possible.

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

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.

Currently, Symbolics.jl has a Groebner basis implementation which is able to convert a myriad of symbolic expressions into multi-variate polynomials. This can be incredibly useful for solving functions for their roots, but to do so, a root finder for these generated polynomials must be implemented. Moreover, multiple users of Symbolics.jl have requested a symbolic nonlinear solver. As such, the project aims to complete the following: 1- Solve single variable polynomials (even high degree ones n ≥ 4) and multi-variable polynomials (over 2 dimensions or more) 2- Solve transcendental / other types of non-linear equations (highly requested: issues #961, #468, and #866) 3- Ensure that the implementation is well tested and well documented to make it more user-friendly and help out future contributors of the project.

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

<p>Aim is to build all the portions of the FastAI.jl package, inspired by the fastai Python library, which will provide high-level components that can quickly and easily provide state-of-the-art results for tabular tasks, and provide low-level components that can be mixed and matched to build new approaches.</p> <p>This will include handling tabular data of all kinds of format, performing transformations on it if required, creating a model using best practices and entity embeddings, and being able to train the created model.</p> <p>All this will be done without compromising in ease of use, flexibility, or performance, due to the benefits Julia provides, along with the well designed three layered architecture.</p>

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>Implementation of mid-level features - specifically routing, load-balancing, cookie/session handling, and authentication.</p>

<p>Virtually all properties of interest arise from electronic interactions between the atoms of a crystal.</p> <p>The work I propose aims to develop a physics-informed graph convolutional neural network architecture, inspired by the <a href="https://en.wikipedia.org/wiki/Tight_binding" target="_blank">Tight-Binding model</a> formalism. This would help us initialise weights with information from the Slater-Koster tables made available as a priori, which would theoretically help derive a more realistic, accurate and data-efficient representation.</p> <p>In addition to this, I also aim to help design and develop essential parts of <a href="https://github.com/Chemellia" target="_blank">Chemellia</a>; primarily <a href="https://github.com/Chemellia/ChemistryFeaturization.jl" target="_blank">ChemistryFeaturization.jl</a>.</p>

The proposal aims to integrate the Julia package Agents.jl (for agent-based modeling) with ReinforcementLearning.jl or Crux.jl, enabling intelligent agents in simulations to learn optimal policies via reinforcement learning. The integration will allow for dynamic, reward-based behaviors rather than static rule-based actions. The project involves updating the chosen RL library for compatibility with the latest Julia version, building a lightweight interface (ABMEnv) to connect it with Agents.jl, and showcasing the integration through example applications like herding, civil violence, and predator-prey models. This work will expand the capabilities of Julia’s ecosystem for researchers in fields such as economics, social sciences, and robotics, while offering a standardized and accessible way to combine RL and ABM.

Reachability analysis deals with uncertainty propagation in dynamical systems. Given an initial set, modeling the uncertainty on the initial state, it aims to answer the question "What is the set containing all possible final states?" This question is relevant in several domains such as safety-critical applications and systems verification. Traditional approaches have mainly concentrated to convex sets, which can lead to overestimation of the final state when this is actually non-convex (so-called wrapping effect). Recently, Sparse Polynomial Zonotopes (SPZ) have been introduced as a set representation for both convex and non-convex sets. SPZ have been shown to have a compact representation that allows efficient manipulation. The goal of this project is to implement Sparse Polynomial Zonotopes in LazySets.jl and the corresponding reachability algorithms in ReachabilityAnalysis.jl for the JuliaReach organization. The final result will be a state-of-the-art (SOTA) toolbox for reachability analysis with sparse polynomial zonotopes, together with systematic benchmarks comparing our Julia implementation both to different implementations of the same approach and other SOTA approaches in reachability analysis.

The main goal of this project is to develop the R interface for JuliaBUGS, enabling a broader range of users already familiar with these languages to leverage the features of JuliaBUGS. This integration will not only facilitate the use of JuliaBUGS’ concise formulation alongside modern methods such as Hamiltonian Monte Carlo (HMC) and Automatic Differentiation (AD) but will also attract new users, helping to expand, consolidate, and strengthen the Julia community. The project will be under the umbrella project Turing.jl, and will have a duration of 175 hours.

Pluto uses the Distributed module (part of Julia's stdlib) to create worker processes and to send Julia data structures between them. These worker processes cannot create other processes themselves, meaning that —in practice— Pluto notebooks cannot use Distributed. This project aims to solve this problem by replacing Distributed in the Pluto codebase with a new package for inter-processes communication, so that Pluto notebooks can use Distributed without any issues.

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

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.

<p>I want to write code to translate the syntax supported by Query.jl into SQL. Then, the queries can be sent to a variety of database softwares. I can take inspiration from implementations in other programming languages (notably LINQ). This work will benefit any user who works with tabular data in Julia. The process to translate code to work optimally with columns might overlap with the process of translating code into SQL. If I am successful translating to SQL code, I will start working on column-based optimizations afterwards</p>

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.

This project aims to significantly enhance the search experience within documentation generated by Documenter.jl. The current client-side search encounters difficulties accurately indexing and retrieving results for Julia-specific syntax, leading to suboptimal relevance. Furthermore, issues like unnecessarily large search indices and repeated listing of the same location hinder usability. This proposal outlines a plan to address these shortcomings by: 1) Implementing search performance benchmarks (relevance, precision/recall, index size) to measure and guide improvements. 2) Developing and integrating an improved, Julia-aware tokenizer within the search JavaScript. 3) Optimizing the index by investigating and removing redundant data, ensuring unique location entries are stored, and adding warnings for potentially problematic large indices. 4) Creating comprehensive developer documentation for the enhanced search system. The outcome will be a more robust, accurate, and efficient search capability for users navigating Julia package documentation.

<p>This project aims to improve the tooling for tensor network algorithms in julia and demonstrate advantages of julia - composability, performance, ecosystem among others - by implementing cutting edge differentiable tensor network algorithms that integrate tools from machine learning, quantum mechanics and mathematical optimisation. The end-result will be a new julia implementation of the einsum-interface and a cutting edge package for differentiable tensor network algorithms, reproducing results of a recent paper that represents the new state-of-the-art in infinite two-dimensional tensor networks.</p>