GSoC 2026 Kickoff: Distributed Linear Solvers in LinearSolve.jl

Hello everyone!

I am Jash Ambaliya, a pre-final year Computer Science and Engineering student from India, and I am excited to share that I will be contributing to SciML this summer through Google Summer of Code 2026. My project is distributed linear solver support in LinearSolve.jl, mentored by Chris Rackauckas and Oscar Smith.

LinearSolve.jl provides a common interface for solving linear systems across many backends, which makes it a key building block for the broader SciML ecosystem. A lot of downstream tooling can already switch between direct and iterative solvers without changing user code, but large distributed HPC workloads still need better support. This project is about closing that gap by extending LinearSolve.jl so that distributed sparse and dense solves fit naturally into the same solve(prob, alg) workflow.

Why this project matters

Large scientific and engineering problems often produce linear systems that are too big for a single machine. In practice, those systems are distributed across MPI ranks, and solving them efficiently requires distributed solver libraries. The goal of this project is to let users access those capabilities through the same high-level LinearSolve interface they already use for serial and shared-memory problems.

That means:

• enabling MPI-based sparse solves through PETSc.jl
• extending HYPRE.jl integration so communicator-aware distributed construction works directly from Julia inputs
• adding a PartitionedSolvers.jl integration for PSparseMatrix / PVector workflows
• preserving LinearSolve’s extension-based design so users only pay for what they load

The core idea is not to build a separate distributed API, but to make distributed backends feel like a natural continuation of the existing LinearSolve design.

Project roadmap

The project is organized into three main deliverables, plus one stretch goal.

1. PETSc integration improvements

The first deliverable is improving the distributed PETSc path in LinearSolve.jl. The work here focuses on:

• distributed assembly for plain Julia SparseMatrixCSC inputs on MPI communicators
• correct scatter/gather behavior so solves work cleanly across ranks
• cache reuse for repeated solves
• tests and documentation for the multi-rank workflow

The goal is that users can start from ordinary Julia sparse matrices, run under MPI, and use PETScAlgorithm without having to manually rebuild their problem in a separate abstraction.

2. HYPRE distributed construction support

The second deliverable is extending HYPREAlgorithm with communicator-aware distributed construction. This includes:

• adding a comm keyword to HYPREAlgorithm
• automatically turning plain Julia matrices and vectors into distributed HYPREMatrix / HYPREVector objects
• verifying the new multi-rank path with tests and documentation

This should make HYPRE easier to use from standard Julia code while still keeping the serial path intact.

3. PartitionedSolvers integration

The third deliverable is adding a new PartitionedSolversAlgorithm for PartitionedArrays.jl-based distributed problems. This includes:

• creating the extension and algorithm type
• validating PSparseMatrix / PVector inputs
• delegating solves to PartitionedSolvers.jl
• supporting cache reuse and automatic algorithm selection
• testing both serial debug-array and MPI-backed workflows

This part is especially interesting because it connects LinearSolve to a more native Julia distributed-array ecosystem.

Stretch goal: Elemental

If the main deliverables are completed early and in stable shape, the stretch goal is an Elemental.jl integration for dense distributed factorizations.

Technical direction

One of the guiding constraints of this project is to preserve LinearSolve.jl’s extension-based architecture. These integrations should not turn distributed solvers into hard dependencies for everyone. Instead, each backend should remain a focused package extension that loads only when the relevant solver package is available.

That keeps the design aligned with the rest of SciML:

• minimal dependency cost for users who do not need distributed solvers
• backend-specific logic isolated in extensions
• a consistent solver interface across serial and distributed settings

What I will share during the summer

I plan to post regular updates as the project moves forward. Those posts will focus on both implementation and engineering tradeoffs, including topics like:

• distributed sparse matrix assembly in PETSc
• communicator-aware solver construction in HYPRE
• cache reuse and repeated solves in distributed workflows
• how PartitionedArrays.jl and PartitionedSolvers.jl fit into the LinearSolve interface
• testing and documentation challenges for MPI-driven execution models

I want these updates to be useful both as progress reports and as technical notes for anyone interested in distributed solver integration in Julia.

Closing

I am grateful to the SciML community, and especially to my mentors Chris Rackauckas and Oscar Smith, for the opportunity to work on this project. I am looking forward to spending the summer pushing LinearSolve.jl further into the distributed/HPC space and making these workflows easier to access from Julia.

If you are interested in distributed scientific computing, solver interfaces, or SciML infrastructure, feel free to follow along. I will be sharing progress as the project develops.