diff --git a/ServerModules.cfg b/ServerModules.cfg
index 2785ac5d2e..b3947ac77b 100644
--- a/ServerModules.cfg
+++ b/ServerModules.cfg
@@ -30,6 +30,7 @@ SegmentedMsg
 SequenceMsg
 SetMsg
 SortMsg
+SparseMatrixMsg
 StatsMsg
 TimeClassMsg
 TransferMsg
diff --git a/arkouda/sparrayclass.py b/arkouda/sparrayclass.py
index 4af23abe03..7e859f6a77 100644
--- a/arkouda/sparrayclass.py
+++ b/arkouda/sparrayclass.py
@@ -1,17 +1,23 @@
 from __future__ import annotations
 
 import builtins
-from typing import Optional, Sequence, Union
+from typing import Optional, Sequence, Union, cast
 
 import numpy as np
 from typeguard import typechecked
 
 from arkouda.client import generic_msg
-from arkouda.dtypes import dtype, int_scalars
+from arkouda.dtypes import NumericDTypes, dtype, int_scalars
 from arkouda.logger import getArkoudaLogger
+from arkouda.pdarrayclass import create_pdarrays, pdarray
 
 logger = getArkoudaLogger(name="sparrayclass")
 
+__all__ = [
+    "sparray",
+    "create_sparray",
+]
+
 
 class sparray:
     """
@@ -94,6 +100,37 @@ def __str__(self):  # This won't work out of the box for sparrays need to add th
     #     print("Called repr")
     #     return generic_msg(cmd="repr", args={"array": self, "printThresh": sparrayIterThresh})
 
+    """
+    Converts the sparse matrix to a list of 3 pdarrays (rows, cols, vals)
+
+    Returns
+    -------
+    List[ak.pdarray]
+        A list of 3 pdarrays which contain the row indices, the column indices,
+        and the values at the respective indices within the sparse matrix.
+    Examples
+    --------
+    >>> a = ak.random_sparse_matrix(100,0.2,"CSR");
+    >>> a.to_pdarray()
+    [array([1 1 1 ... 100 100 100]), array([17 21 29 ... 75 77 85]), array([0 0 0 ... 0 0 0])]
+    """
+
+    @typechecked
+    def to_pdarray(self):
+        dtype = self.dtype
+        dtype_name = cast(np.dtype, dtype).name
+        # check dtype for error
+        if dtype_name not in NumericDTypes:
+            raise TypeError(f"unsupported dtype {dtype}")
+        responseArrays = generic_msg(cmd="sparse_to_pdarrays", args={"matrix": self})
+        array_list = create_pdarrays(responseArrays)
+        return array_list
+
+    """"""
+
+    def fill_vals(self, a: pdarray):
+        generic_msg(cmd="fill_sparse_vals", args={"matrix": self, "vals": a})
+
 
 # creates sparray object
 #   only after:
diff --git a/pytest.ini b/pytest.ini
index 26088e57fe..8b7316accf 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -44,6 +44,7 @@ testpaths =
     tests/series_test.py
     tests/setops_test.py
     tests/sort_test.py
+    tests/sparse_test.py
     tests/stats_test.py
     tests/string_test.py
     tests/symbol_table_test.py
diff --git a/src/SparseMatrix.chpl b/src/SparseMatrix.chpl
index ad6867b441..b2cfac5550 100644
--- a/src/SparseMatrix.chpl
+++ b/src/SparseMatrix.chpl
@@ -1,17 +1,57 @@
 module SparseMatrix {
 
   public use SpsMatUtil;
+  use ArkoudaSparseMatrixCompat;
+
+
+  // Quick and dirty, not permanent
+  proc fillSparseMatrix(ref spsMat, const A: [?D] ?eltType) throws {
+    if A.rank != 1 then
+        throw getErrorWithContext(
+                        msg="fill vals requires a 1D array; got a %iD array".format(A.rank),
+                        lineNumber=getLineNumber(),
+                        routineName=getRoutineName(),
+                        moduleName=getModuleName(),
+                        errorClass="IllegalArgumentError"
+                        );
+    if A.size != spsMat.domain.getNNZ() then
+        throw getErrorWithContext(
+                        msg="fill vals requires an array of the same size as the sparse matrix; got %i elements, expected %i".format(A.size, spsMat.domain.getNNZ()),
+                        lineNumber=getLineNumber(),
+                        routineName=getRoutineName(),
+                        moduleName=getModuleName(),
+                        errorClass="IllegalArgumentError"
+                        );
+    if eltType != spsMat.eltType then
+        throw getErrorWithContext(
+                        msg="fill vals requires an array of the same type as the sparse matrix; got %s, expected %s".format(eltType, spsMat.eltType),
+                        lineNumber=getLineNumber(),
+                        routineName=getRoutineName(),
+                        moduleName=getModuleName(),
+                        errorClass="IllegalArgumentError"
+                        );
+    for((i,j), idx) in zip(spsMat.domain,A.domain) {
+        spsMat[i,j] = A[idx];
+    }
+  }
 
+  proc sparseMatToPdarray(const ref spsMat, ref rows, ref cols, ref vals){
+    for((i,j), idx) in zip(spsMat.domain,0..) {
+      rows[idx] = i;
+      cols[idx] = j;
+      vals[idx] = spsMat[i, j];
+    }
+  }
   // sparse, outer, matrix-matrix multiplication algorithm; A is assumed
   // CSC and B CSR
-  proc sparseMatMatMult(A, B) {
-    var spsData: sparseMatDat;
+  // proc sparseMatMatMult(A, B) {
+  //   var spsData: sparseMatDat;
 
-    sparseMatMatMult(A, B, spsData);
+  //   sparseMatMatMult(A, B, spsData);
 
-    var C = makeSparseMat(A.domain.parentDom, spsData);
-    return C;
-  }
+  //   var C = makeSparseMat(A.domain.parentDom, spsData);
+  //   return C;
+  // }
 
   // This version forms the guts of the above and permits a running set
   // of nonzeroes to be passed in and updated rather than assuming that
diff --git a/src/SparseMatrixMsg.chpl b/src/SparseMatrixMsg.chpl
index f28bcd0c82..9709649701 100644
--- a/src/SparseMatrixMsg.chpl
+++ b/src/SparseMatrixMsg.chpl
@@ -53,7 +53,6 @@ module SparseMatrixMsg {
                 return new MsgTuple(errorMsg, MsgType.ERROR);
             }
         }
-
     }
 
 
@@ -80,9 +79,78 @@ module SparseMatrixMsg {
     }
 
 
+    proc sparseMatrixtoPdarray(cmd: string, msgArgs: borrowed MessageArgs, st: borrowed SymTab): MsgTuple throws {
+        var repMsg: string; // response message with the details of the new arr
+
+        var gEnt = getGenericSparseArrayEntry(msgArgs.getValueOf("matrix"), st);
+
+        var size = gEnt.nnz;
+        var rows = makeDistArray(size, int);
+        var cols = makeDistArray(size, int);
+        var vals = makeDistArray(size, int);
+
+        if gEnt.layoutStr=="CSC" {
+            // Hardcode for int right now
+            var sparrayEntry = gEnt.toSparseSymEntry(int, dimensions=2, layout.CSC);
+            sparseMatToPdarray(sparrayEntry.a, rows, cols, vals);
+        } else if gEnt.layoutStr=="CSR" {
+            // Hardcode for int right now
+            var sparrayEntry = gEnt.toSparseSymEntry(int, dimensions=2, layout.CSR);
+            sparseMatToPdarray(sparrayEntry.a, rows, cols, vals);
+        } else {
+            throw getErrorWithContext(
+                                    msg="unsupported layout for sparse matrix: %s".format(gEnt.layoutStr),
+                                    lineNumber=getLineNumber(),
+                                    routineName=getRoutineName(),
+                                    moduleName=getModuleName(),
+                                    errorClass="NotImplementedError"
+                                    );
+        }
+
+        var responses: [0..2] MsgTuple;
+        responses[0] = st.insert(createSymEntry(rows));
+        responses[1] = st.insert(createSymEntry(cols));
+        responses[2] = st.insert(createSymEntry(vals));
+        sparseLogger.debug(getModuleName(),getRoutineName(),getLineNumber(), "Converted sparse matrix to pdarray");
+        return MsgTuple.fromResponses(responses);
+    }
+
+
+    proc fillSparseMatrixMsg(cmd: string, msgArgs: borrowed MessageArgs, st: borrowed SymTab): MsgTuple throws {
+        var repMsg: string; // response message with the details of the new arr
+
+        var gEnt = getGenericSparseArrayEntry(msgArgs.getValueOf("matrix"), st);
+        var gEntVals: borrowed GenSymEntry = getGenericTypedArrayEntry(msgArgs.getValueOf("vals"), st);
+
+        //Hardcode int for now
+        var vals = toSymEntry(gEntVals,int);
+        if gEnt.layoutStr=="CSC" {
+            // Hardcode for int right now
+            var sparrayEntry = gEnt.toSparseSymEntry(int, dimensions=2, layout.CSC);
+            fillSparseMatrix(sparrayEntry.a, vals.a);
+        } else if gEnt.layoutStr=="CSR" {
+            // Hardcode for int right now
+            var sparrayEntry = gEnt.toSparseSymEntry(int, dimensions=2, layout.CSR);
+            fillSparseMatrix(sparrayEntry.a, vals.a);
+        } else {
+            throw getErrorWithContext(
+                                    msg="unsupported layout for sparse matrix: %s".format(gEnt.layoutStr),
+                                    lineNumber=getLineNumber(),
+                                    routineName=getRoutineName(),
+                                    moduleName=getModuleName(),
+                                    errorClass="NotImplementedError"
+                                    );
+        }
+        sparseLogger.debug(getModuleName(),getRoutineName(),getLineNumber(), "Filled sparse Array with values");
+        return MsgTuple.success();
+    }
+
+
 
     use CommandMap;
     registerFunction("random_sparse_matrix", randomSparseMatrixMsg, getModuleName());
     registerFunction("sparse_matrix_matrix_mult", sparseMatrixMatrixMultMsg, getModuleName());
+    registerFunction("sparse_to_pdarrays", sparseMatrixtoPdarray, getModuleName());
+    registerFunction("fill_sparse_vals", fillSparseMatrixMsg, getModuleName());
 
-}
\ No newline at end of file
+}
diff --git a/src/compat/eq-20/ArkoudaSparseMatrixCompat.chpl b/src/compat/eq-20/ArkoudaSparseMatrixCompat.chpl
new file mode 100644
index 0000000000..1ab8429fd5
--- /dev/null
+++ b/src/compat/eq-20/ArkoudaSparseMatrixCompat.chpl
@@ -0,0 +1,86 @@
+module ArkoudaSparseMatrixCompat {
+  use SparseBlockDist;
+
+  proc SparseBlockDom.setLocalSubdomain(locIndices, loc: locale = here) {
+    if loc != here then
+      halt("setLocalSubdomain() doesn't currently support remote updates");
+    ref myBlock = this.myLocDom!.mySparseBlock;
+    if myBlock.type != locIndices.type then
+      compilerError("setLocalSubdomain() expects its argument to be of type ",
+                     myBlock.type:string);
+    else
+      myBlock = locIndices;
+  }
+
+  proc SparseBlockArr.getLocalSubarray(localeRow, localeCol) const ref {
+    return this.locArr[localeRow, localeCol]!.myElems;
+  }
+
+  proc SparseBlockArr.getLocalSubarray(localeIdx) const ref {
+    return this.locArr[localeIdx]!.myElems;
+  }
+
+  proc SparseBlockArr.setLocalSubarray(locNonzeroes, loc: locale = here) {
+    if loc != here then
+      halt("setLocalSubarray() doesn't currently support remote updates");
+    ref myBlock = this.myLocArr!.myElems;
+    if myBlock.type != locNonzeroes.type then
+      compilerError("setLocalSubarray() expects its argument to be of type ",
+                    myBlock.type:string);
+    else
+      myBlock.data = locNonzeroes.data;
+  }
+
+  proc SparseBlockDom.dsiTargetLocales() const ref {
+    return dist.targetLocales;
+  }
+
+  proc SparseBlockArr.dsiTargetLocales() const ref {
+    return dom.dsiTargetLocales();
+  }
+
+  use LayoutCS;
+
+  proc CSDom.rows() {
+    return this.rowRange;
+  }
+
+  proc CSDom.cols() {
+    return this.colRange;
+  }
+
+  @chpldoc.nodoc
+  iter CSDom.uidsInRowCol(rc) {
+    for uid in startIdx[rc]..<startIdx[rc+1] do
+      yield uid;
+  }
+
+  proc CSArr.rows() {
+    return this.dom.rows();
+  }
+
+  proc CSArr.cols() {
+    return this.dom.cols();
+  }
+
+  @chpldoc.nodoc
+  iter CSArr.indsAndVals(rc) {
+    ref dom = this.dom;
+    for uid in dom.uidsInRowCol(rc) do
+      yield (dom.idx[uid], this.data[uid]);
+  }
+
+  iter CSArr.colsAndVals(r) {
+    if this.dom.compressRows == false then
+      compilerError("Can't (efficiently) iterate over rows using a CSC layout");
+    for colVal in indsAndVals(r) do
+      yield colVal;
+  }
+
+  iter CSArr.rowsAndVals(c) {
+    if this.dom.compressRows == true then
+      compilerError("Can't (efficiently) iterate over columns using a CSR layout");
+    for rowVal in indsAndVals(c) do
+      yield rowVal;
+  }
+}
diff --git a/src/compat/eq-21/ArkoudaSparseMatrixCompat.chpl b/src/compat/eq-21/ArkoudaSparseMatrixCompat.chpl
new file mode 100644
index 0000000000..8d9ff88170
--- /dev/null
+++ b/src/compat/eq-21/ArkoudaSparseMatrixCompat.chpl
@@ -0,0 +1 @@
+module ArkoudaSparseMatrixCompat {}
diff --git a/src/compat/ge-22/ArkoudaSparseMatrixCompat.chpl b/src/compat/ge-22/ArkoudaSparseMatrixCompat.chpl
new file mode 100644
index 0000000000..8d9ff88170
--- /dev/null
+++ b/src/compat/ge-22/ArkoudaSparseMatrixCompat.chpl
@@ -0,0 +1 @@
+module ArkoudaSparseMatrixCompat {}
diff --git a/tests/sparse_test.py b/tests/sparse_test.py
new file mode 100644
index 0000000000..44892d2a3b
--- /dev/null
+++ b/tests/sparse_test.py
@@ -0,0 +1,94 @@
+import numpy as np
+import pytest
+import arkouda as ak
+
+class TestSparse:
+
+    def test_utils(self):
+        csc = ak.random_sparse_matrix(10, 0.2, "CSC")
+        csr = ak.random_sparse_matrix(10, 0.2, "CSR")
+        vals_csc = csc.to_pdarray()[2].to_ndarray()
+        vals_csr = csr.to_pdarray()[2].to_ndarray()
+        assert np.all(vals_csc == 0)
+        assert np.all(vals_csr == 0)
+        fill_vals_csc = ak.randint(0, 10, csc.nnz)
+        fill_vals_csr = ak.randint(0, 10, csr.nnz)
+        csc.fill_vals(fill_vals_csc)
+        csr.fill_vals(fill_vals_csr)
+        vals_csc = csc.to_pdarray()[2].to_ndarray()
+        vals_csr = csr.to_pdarray()[2].to_ndarray()
+        assert np.all(vals_csc == fill_vals_csc.to_ndarray())
+        assert np.all(vals_csr == fill_vals_csr.to_ndarray())
+
+
+
+    def test_matmatmult(self):
+        # Create a reference for matrix multiplication in python:
+        def matmatmult(rowsA, colsA, valsA, rowsB, colsB, valsB):
+            """
+            Perform matrix-matrix multiplication of two sparse matrices represented by
+            3 arrays of rows, cols, and vals.
+            A . B
+            Parameters
+            ----------
+            rowsA : list or array-like
+                Row indices of non-zero elements in matrix A.
+            colsA : list or array-like
+                Column indices of non-zero elements in matrix A.
+            valsA : list or array-like
+                Values of non-zero elements in matrix A.
+            rowsB : list or array-like
+                Row indices of non-zero elements in matrix B.
+            colsB : list or array-like
+                Column indices of non-zero elements in matrix B.
+            valsB : list or array-like
+                Values of non-zero elements in matrix B.
+
+            Returns
+            -------
+            result_rows : list
+                Row indices of non-zero elements in the result matrix.
+            result_cols : list
+                Column indices of non-zero elements in the result matrix.
+            result_vals : list
+                Values of non-zero elements in the result matrix.
+            """
+            from collections import defaultdict
+
+            # Dictionary to accumulate the results
+            result = defaultdict(float)
+
+            # Create a dictionary for quick lookup of matrix B elements
+            B_dict = defaultdict(list)
+            for r, c, v in zip(rowsB, colsB, valsB):
+                B_dict[r].append((c, v))
+
+            # Perform the multiplication
+            for rA, cA, vA in zip(rowsA, colsA, valsA):
+                if cA in B_dict:
+                    for cB, vB in B_dict[cA]:
+                        result[(rA, cB)] += vA * vB
+
+            # Extract the results into separate lists
+            result_rows, result_cols, result_vals = zip(*[(r, c, v) for (r, c), v in result.items()])
+
+            return list(result_rows), list(result_cols), list(result_vals)
+        matA = ak.random_sparse_matrix(10, 1, 'CSC') # Make it fully dense to make testing easy
+        matB = ak.random_sparse_matrix(10, 1, 'CSR') # Make it fully dense to make testing easy
+        fill_vals_a = ak.randint(0, 10, matA.nnz)
+        fill_vals_b = ak.randint(0, 10, matB.nnz)
+        matA.fill_vals(fill_vals_a)
+        matB.fill_vals(fill_vals_b)
+        rowsA, colsA, valsA = (arr.to_ndarray() for arr in matA.to_pdarray())
+        rowsB, colsB, valsB = (arr.to_ndarray() for arr in matB.to_pdarray())
+        assert np.all(valsA == fill_vals_a.to_ndarray())
+        assert np.all(valsB == fill_vals_b.to_ndarray())
+        ans_rows, ans_cols, ans_vals = matmatmult(rowsA, colsA, valsA, rowsB, colsB, valsB)
+
+        result = ak.sparse_matrix_matrix_mult(matA, matB)
+        result_rows, result_cols, result_vals = (arr.to_ndarray() for arr in result.to_pdarray())
+
+        # Check the result is correct
+        assert np.all(result_rows == ans_rows)
+        assert np.all(result_cols == ans_cols)
+        assert np.all(result_vals == ans_vals)