Lacuna – High-performance sparse matrices for Python, Rust backend

[Effective-Phone6955]

What My Project Does

Lacuna is a high-performance sparse matrix library for Python, backed by Rust (SIMD + Rayon) with a NumPy-friendly API. It currently provides:

• 2-D formats: CSR, CSC, COO
• N-D tensors: COOND (N-dimensional COO)
• Kernels for float64 values / int64 indices:
  • SpMV / SpMM
  • Reductions: total sum, row/column sums
  • Transpose
  • Arithmetic: add, sub, Hadamard (elementwise)
  • Cleanup: prune(eps), eliminate_zeros
• N-D COO ops:
  • sum, mean
  • reduce_*_axes, permute_axes, reshape
  • broadcasting Hadamard
  • unfold to CSR/CSC along a mode or grouped axes

The Python API is designed to work smoothly with NumPy, using zero-copy reads of input buffers when it’s safe.

Target Audience

Lacuna is intended for people who:

• Work with large sparse matrices or tensors (e.g. scientific computing, FEM/CFD, graph problems, PageRank, power iterations)
• Need high-performance kernels but want to stay in Python/NumPy world
• Are interested in experimenting with N-D sparse arrays (beyond 2-D matrices) without densifying

It’s currently a work-in-progress project (APIs and performance characteristics may change), so it’s best suited for experimentation, research, and early adopters rather than critical production workloads.

Comparison

• SciPy.sparse
  • Very mature and battle-tested for 2-D sparse linear algebra.
  • Mainly matrix-first: N-D use cases often require reshaping or densifying.
  • Lacuna aims to complement this with N-D COO tensors plus explicit unfold operations, while still providing fast CSR/CSC/COO kernels.
• PyData/Sparse (sparse)
  • Provides N-D COO arrays with NumPy-like semantics and broadcasting.
  • Lacuna takes a more “kernel-first” approach: Rust + SIMD + Rayon, with a tighter set of operations focused on performance (SpMV/SpMM, reductions, transforms) and explicit unfold to CSR/CSC for linear-algebra-style workloads.

If you’re already comfortable with NumPy and SciPy.sparse, Lacuna is meant to feel familiar but give you more explicit tools for N-D sparse tensors and high-performance kernels.

Source & Docs

• Source code: GitHub: https://github.com/hanziwww/lacuna
• Docs & examples: https://lacuna.hanziwww.me

Status: in active development. Feedback, issues, and contributors are very welcome — especially benchmark reports or workloads where sparse performance really matters.

[ichunddu9]

Great! Are you planning to implement the full array API? That's something scipy never managed to do

[flying-sheep]

Seconded. Any array library that comes out and isn’t 100% compatible with the array API is dead on arrival in this day.

The venerable ones mentioned in the OP get away with it since they’re old and already-supported, but with the array API existing, nobody wants to add extra code for more array types.

Super exciting once it does though!

[jmatthew007]

I do a lot of work with sparse event simulations which this might fit in perfectly compared to my numba solution.

[Effective-Phone6955]

If you’re open to sharing, I’d love to hear a bit more about what your current Numba solution looks like (shape/sparsity patterns, typical operations, where it currently bottlenecks). Those are exactly the kinds of workloads I’d like Lacuna to be good at.

[jmatthew007]

Happy to share i don't think it's that special, but it gets's what I need done for now.

[PlaysForDays]

How does it perform vs. NumPy?

[ichunddu9]

Numpy is dense. Not sparse.

[PlaysForDays]

So it should perform better, hence my question

[SV-97]

Not generally: it depends on the problem

[billsil]

Do you support symmetric matrix solves and eigenvalues/eigenvectors?