numkong 7.0.0 → 7.4.1

package/include/numkong/dots/rvv.h

@@ -77,24 +77,24 @@ static nk_u16_t const nk_e3m2_magnitude_lut_rvv_[32] = {0,  1,   2,   3,   4,
                                                         14, 16,  20,  24,  28,  32,  40,  48,  56,  64, 80,
                                                         96, 112, 128, 160, 192, 224, 256, 320, 384, 448};
 
-#pragma region Single Precision Floats
+#pragma region F32 Floats
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_f32_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     // Break power-of-2 strides for cache associativity
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f32_t) +
            column_count * sizeof(nk_f64_t); // per-column norms
 }
 
 NK_PUBLIC void nk_dots_pack_f32_rvv(nk_f32_t const *b, nk_size_t column_count, nk_size_t depth,
                                     nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -103,12 +103,24 @@ NK_PUBLIC void nk_dots_pack_f32_rvv(nk_f32_t const *b, nk_size_t column_count, n
 
     nk_f32_t *packed = (nk_f32_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f32_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_f32_t const *src = (nk_f32_t const *)((char const *)b + column * b_stride_in_bytes);
         nk_f32_t *dst = packed + column * depth_padded;
-        for (nk_size_t k = 0; k < depth; ++k) dst[k] = src[k];
+        for (nk_size_t k = 0; k < depth;) {
+            nk_size_t vector_length = __riscv_vsetvl_e32m8(depth - k);
+            __riscv_vse32_v_f32m8(dst + k, __riscv_vle32_v_f32m8(src + k, vector_length), vector_length);
+            k += vector_length;
+        }
     }
 
     // Append per-column norms after packed data
@@ -158,11 +170,11 @@ NK_INTERNAL void nk_dots_packed_f32_rvv_aligned_(nk_f32_t const *a_matrix, void
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -186,13 +198,13 @@ NK_INTERNAL void nk_dots_packed_f32_rvv_aligned_(nk_f32_t const *a_matrix, void
             // Horizontal reduce directly to f64
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
             c_row_2[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, max_vector_length));
             c_row_3[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows (mr < 4)
@@ -201,8 +213,8 @@ NK_INTERNAL void nk_dots_packed_f32_rvv_aligned_(nk_f32_t const *a_matrix, void
         nk_f64_t *c_row = (nk_f64_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -214,7 +226,7 @@ NK_INTERNAL void nk_dots_packed_f32_rvv_aligned_(nk_f32_t const *a_matrix, void
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -225,9 +237,10 @@ NK_INTERNAL void nk_dots_packed_f32_rvv_aligned_(nk_f32_t const *a_matrix, void
  *  Dispatches to the aligned kernel for all cases — RVV's `vsetvl` handles partial
  *  vectors naturally, so no separate edge kernel is needed.
  */
-NK_PUBLIC void nk_dots_packed_f32_rvv(nk_f32_t const *a, void const *b_packed, nk_f64_t *c, nk_size_t m, nk_size_t n,
-                                      nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_f32_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_f32_rvv(nk_f32_t const *a, void const *b_packed, nk_f64_t *c, nk_size_t rows,
+                                      nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                      nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_f32_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -236,19 +249,19 @@ NK_PUBLIC void nk_dots_packed_f32_rvv(nk_f32_t const *a, void const *b_packed, n
  *  Uses f64 widened accumulation via `vfwmacc_vv_f64m4` for precision.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_f32_rvv(nk_f32_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                         nk_size_t stride, nk_f64_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_f32_rvv(nk_f32_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                         nk_size_t stride_in_bytes, nk_f64_t *result, nk_size_t result_stride_in_bytes,
                                          nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const stride_elements = stride / sizeof(nk_f32_t);
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f64_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f64_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
         nk_f32_t const *a_i = vectors + i * stride_elements;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
+        for (nk_size_t j = i; j < vectors_count; ++j) {
             nk_f32_t const *a_j = vectors + j * stride_elements;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -260,31 +273,31 @@ NK_PUBLIC void nk_dots_symmetric_f32_rvv(nk_f32_t const *vectors, nk_size_t n_ve
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f64_t dot = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Single Precision Floats
+#pragma endregion F32 Floats
 
-#pragma region Double Precision Floats
+#pragma region F64 Floats
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_f64_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e64m4();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e64m4();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f64_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f64_t) +
            column_count * sizeof(nk_f64_t); // per-column norms
 }
 
 NK_PUBLIC void nk_dots_pack_f64_rvv(nk_f64_t const *b, nk_size_t column_count, nk_size_t depth,
                                     nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e64m4();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e64m4();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f64_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -293,12 +306,24 @@ NK_PUBLIC void nk_dots_pack_f64_rvv(nk_f64_t const *b, nk_size_t column_count, n
 
     nk_f64_t *packed = (nk_f64_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f64_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_f64_t const *src = (nk_f64_t const *)((char const *)b + column * b_stride_in_bytes);
         nk_f64_t *dst = packed + column * depth_padded;
-        for (nk_size_t k = 0; k < depth; ++k) dst[k] = src[k];
+        for (nk_size_t k = 0; k < depth;) {
+            nk_size_t vector_length = __riscv_vsetvl_e64m8(depth - k);
+            __riscv_vse64_v_f64m8(dst + k, __riscv_vle64_v_f64m8(src + k, vector_length), vector_length);
+            k += vector_length;
+        }
     }
 
     // Append per-column norms after packed data
@@ -341,11 +366,11 @@ NK_INTERNAL void nk_dots_packed_f64_rvv_aligned_(nk_f64_t const *a_matrix, void
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f64_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e64m4();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t compensation_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t compensation_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e64m4();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t compensation_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t compensation_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -384,9 +409,9 @@ NK_INTERNAL void nk_dots_packed_f64_rvv_aligned_(nk_f64_t const *a_matrix, void
             // Horizontal reduce
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows
@@ -395,9 +420,9 @@ NK_INTERNAL void nk_dots_packed_f64_rvv_aligned_(nk_f64_t const *a_matrix, void
         nk_f64_t *c_row = (nk_f64_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f64_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e64m4();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t compensation_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e64m4();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t compensation_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -419,7 +444,7 @@ NK_INTERNAL void nk_dots_packed_f64_rvv_aligned_(nk_f64_t const *a_matrix, void
 
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -427,9 +452,10 @@ NK_INTERNAL void nk_dots_packed_f64_rvv_aligned_(nk_f64_t const *a_matrix, void
 /**
  *  @brief  Public f64 packed GEMM wrapper matching the declared signature in dots.h.
  */
-NK_PUBLIC void nk_dots_packed_f64_rvv(nk_f64_t const *a, void const *b_packed, nk_f64_t *c, nk_size_t m, nk_size_t n,
-                                      nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_f64_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_f64_rvv(nk_f64_t const *a, void const *b_packed, nk_f64_t *c, nk_size_t rows,
+                                      nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                      nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_f64_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -438,20 +464,20 @@ NK_PUBLIC void nk_dots_packed_f64_rvv(nk_f64_t const *a, void const *b_packed, n
  *  Uses Kahan compensation over full depth for precision.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_f64_rvv(nk_f64_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                         nk_size_t stride, nk_f64_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_f64_rvv(nk_f64_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                         nk_size_t stride_in_bytes, nk_f64_t *result, nk_size_t result_stride_in_bytes,
                                          nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const stride_elements = stride / sizeof(nk_f64_t);
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f64_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const stride_elements = stride_in_bytes / sizeof(nk_f64_t);
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f64_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
         nk_f64_t const *a_i = vectors + i * stride_elements;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
+        for (nk_size_t j = i; j < vectors_count; ++j) {
             nk_f64_t const *a_j = vectors + j * stride_elements;
-            nk_size_t vlmax = __riscv_vsetvlmax_e64m4();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t compensation_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e64m4();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t compensation_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -473,15 +499,15 @@ NK_PUBLIC void nk_dots_symmetric_f64_rvv(nk_f64_t const *vectors, nk_size_t n_ve
 
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f64_t dot = __riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Double Precision Floats
+#pragma endregion F64 Floats
 
-#pragma region Micro Precision E2M3
+#pragma region E2M3 Floats
 
 /**
  *  @brief  Scalar conversion helper: e2m3 byte → signed i8 (value × 16).
@@ -496,10 +522,10 @@ NK_INTERNAL nk_i8_t nk_e2m3_to_i8_rvv_(nk_u8_t raw) {
 }
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_e2m3_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_i8_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -512,10 +538,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e2m3_rvv(nk_size_t column_count, nk_size
  */
 NK_PUBLIC void nk_dots_pack_e2m3_rvv(nk_e2m3_t const *b, nk_size_t column_count, nk_size_t depth,
                                      nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -524,7 +550,15 @@ NK_PUBLIC void nk_dots_pack_e2m3_rvv(nk_e2m3_t const *b, nk_size_t column_count,
 
     nk_i8_t *packed = (nk_i8_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_i8_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_u8_t const *src = (nk_u8_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -584,11 +618,11 @@ NK_INTERNAL void nk_dots_packed_e2m3_rvv_aligned_(nk_e2m3_t const *a_matrix, voi
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_2_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_3_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_2_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_3_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -654,16 +688,16 @@ NK_INTERNAL void nk_dots_packed_e2m3_rvv_aligned_(nk_e2m3_t const *a_matrix, voi
             // Horizontal reduce and convert to f32 with scaling
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
             c_row_1[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
             c_row_2[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_2_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_2_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
             c_row_3[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_3_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_3_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
         }
     }
@@ -673,8 +707,8 @@ NK_INTERNAL void nk_dots_packed_e2m3_rvv_aligned_(nk_e2m3_t const *a_matrix, voi
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -693,7 +727,7 @@ NK_INTERNAL void nk_dots_packed_e2m3_rvv_aligned_(nk_e2m3_t const *a_matrix, voi
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax)) *
+                                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length)) *
                             lut_scale_reciprocal;
         }
     }
@@ -702,9 +736,10 @@ NK_INTERNAL void nk_dots_packed_e2m3_rvv_aligned_(nk_e2m3_t const *a_matrix, voi
 /**
  *  @brief  Public e2m3 packed GEMM wrapper matching the declared signature in dots.h.
  */
-NK_PUBLIC void nk_dots_packed_e2m3_rvv(nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                       nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_e2m3_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_e2m3_rvv(nk_e2m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                       nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                       nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_e2m3_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -713,20 +748,20 @@ NK_PUBLIC void nk_dots_packed_e2m3_rvv(nk_e2m3_t const *a, void const *b_packed,
  *  Uses integer i8 LUT arithmetic with i32 accumulation, scaled by 1/256.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_e2m3_rvv(nk_e2m3_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                          nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_e2m3_rvv(nk_e2m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                           nk_size_t row_start, nk_size_t row_count) {
     nk_f32_t const lut_scale_reciprocal = 1.0f / 256.0f;
 
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride_in_bytes;
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride_in_bytes;
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -755,16 +790,16 @@ NK_PUBLIC void nk_dots_symmetric_e2m3_rvv(nk_e2m3_t const *vectors, nk_size_t n_
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                               __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax)) *
+                               __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length)) *
                            lut_scale_reciprocal;
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Micro Precision E2M3
+#pragma endregion E2M3 Floats
 
-#pragma region Micro Precision E3M2
+#pragma region E3M2 Floats
 
 /**
  *  @brief  Scalar conversion helper: e3m2 byte → signed i16 (value × 16).
@@ -779,10 +814,10 @@ NK_INTERNAL nk_i16_t nk_e3m2_to_i16_rvv_(nk_u8_t raw) {
 }
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_e3m2_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e16m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e16m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i16_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_i16_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -795,10 +830,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e3m2_rvv(nk_size_t column_count, nk_size
  */
 NK_PUBLIC void nk_dots_pack_e3m2_rvv(nk_e3m2_t const *b, nk_size_t column_count, nk_size_t depth,
                                      nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e16m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e16m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i16_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -807,7 +842,15 @@ NK_PUBLIC void nk_dots_pack_e3m2_rvv(nk_e3m2_t const *b, nk_size_t column_count,
 
     nk_i16_t *packed = (nk_i16_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_i16_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_u8_t const *src = (nk_u8_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -862,9 +905,9 @@ NK_INTERNAL void nk_dots_packed_e3m2_rvv_aligned_(nk_e3m2_t const *a_matrix, voi
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i16_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -916,10 +959,10 @@ NK_INTERNAL void nk_dots_packed_e3m2_rvv_aligned_(nk_e3m2_t const *a_matrix, voi
             // Horizontal reduce and convert to f32 with scaling
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
             c_row_1[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, vlmax)) *
+                                  __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, max_vector_length)) *
                               lut_scale_reciprocal;
         }
     }
@@ -929,8 +972,8 @@ NK_INTERNAL void nk_dots_packed_e3m2_rvv_aligned_(nk_e3m2_t const *a_matrix, voi
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i16_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -951,7 +994,7 @@ NK_INTERNAL void nk_dots_packed_e3m2_rvv_aligned_(nk_e3m2_t const *a_matrix, voi
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row[column] = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax)) *
+                                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length)) *
                             lut_scale_reciprocal;
         }
     }
@@ -960,9 +1003,10 @@ NK_INTERNAL void nk_dots_packed_e3m2_rvv_aligned_(nk_e3m2_t const *a_matrix, voi
 /**
  *  @brief  Public e3m2 packed GEMM wrapper matching the declared signature in dots.h.
  */
-NK_PUBLIC void nk_dots_packed_e3m2_rvv(nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                       nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_e3m2_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_e3m2_rvv(nk_e3m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                       nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                       nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_e3m2_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -971,20 +1015,20 @@ NK_PUBLIC void nk_dots_packed_e3m2_rvv(nk_e3m2_t const *a, void const *b_packed,
  *  Uses integer i16 LUT arithmetic with i32 widening MAC, scaled by 1/256.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_e3m2_rvv(nk_e3m2_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                          nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_e3m2_rvv(nk_e3m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                           nk_size_t row_start, nk_size_t row_count) {
     nk_f32_t const lut_scale_reciprocal = 1.0f / 256.0f;
 
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride_in_bytes;
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride_in_bytes;
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1023,16 +1067,16 @@ NK_PUBLIC void nk_dots_symmetric_e3m2_rvv(nk_e3m2_t const *vectors, nk_size_t n_
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vmv_x_s_i32m1_i32(
-                               __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax)) *
+                               __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length)) *
                            lut_scale_reciprocal;
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Micro Precision E3M2
+#pragma endregion E3M2 Floats
 
-#pragma region Brain Float 16
+#pragma region BF16 Floats
 
 /**
  *  @brief  Compute the packed buffer size for bf16 GEMM (B stored as f32).
@@ -1041,11 +1085,11 @@ NK_PUBLIC void nk_dots_symmetric_e3m2_rvv(nk_e3m2_t const *vectors, nk_size_t n_
  *  Layout: column-panel with depth-contiguous f32 values, cache-line padding.
  */
 NK_PUBLIC nk_size_t nk_dots_packed_size_bf16_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     // Break power-of-2 strides for cache associativity
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f32_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -1058,10 +1102,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_bf16_rvv(nk_size_t column_count, nk_size
  */
 NK_PUBLIC void nk_dots_pack_bf16_rvv(nk_bf16_t const *b, nk_size_t column_count, nk_size_t depth,
                                      nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -1070,7 +1114,15 @@ NK_PUBLIC void nk_dots_pack_bf16_rvv(nk_bf16_t const *b, nk_size_t column_count,
 
     nk_f32_t *packed = (nk_f32_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f32_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_u16_t const *src = (nk_u16_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -1133,11 +1185,11 @@ NK_INTERNAL void nk_dots_packed_bf16_rvv_aligned_(nk_bf16_t const *a_matrix, voi
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -1166,13 +1218,13 @@ NK_INTERNAL void nk_dots_packed_bf16_rvv_aligned_(nk_bf16_t const *a_matrix, voi
             // Horizontal reduce and narrow to f32
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
             c_row_2[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, max_vector_length));
             c_row_3[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows (mr < 4)
@@ -1181,8 +1233,8 @@ NK_INTERNAL void nk_dots_packed_bf16_rvv_aligned_(nk_bf16_t const *a_matrix, voi
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1195,7 +1247,7 @@ NK_INTERNAL void nk_dots_packed_bf16_rvv_aligned_(nk_bf16_t const *a_matrix, voi
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -1206,9 +1258,10 @@ NK_INTERNAL void nk_dots_packed_bf16_rvv_aligned_(nk_bf16_t const *a_matrix, voi
  *  Dispatches to the aligned kernel for all cases — RVV's `vsetvl` handles partial
  *  vectors naturally, so no separate edge kernel is needed.
  */
-NK_PUBLIC void nk_dots_packed_bf16_rvv(nk_bf16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                       nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_bf16_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_bf16_rvv(nk_bf16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                       nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                       nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_bf16_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -1219,18 +1272,18 @@ NK_PUBLIC void nk_dots_packed_bf16_rvv(nk_bf16_t const *a, void const *b_packed,
  *  Stride is in bytes.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_bf16_rvv(nk_bf16_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                          nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_bf16_rvv(nk_bf16_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                           nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u16_t const *a_i = (nk_u16_t const *)((char const *)vectors + i * stride);
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u16_t const *a_j = (nk_u16_t const *)((char const *)vectors + j * stride);
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+        nk_u16_t const *a_i = (nk_u16_t const *)((char const *)vectors + i * stride_in_bytes);
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u16_t const *a_j = (nk_u16_t const *)((char const *)vectors + j * stride_in_bytes);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1244,15 +1297,15 @@ NK_PUBLIC void nk_dots_symmetric_bf16_rvv(nk_bf16_t const *vectors, nk_size_t n_
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Brain Float 16
+#pragma endregion BF16 Floats
 
-#pragma region Half Precision Floats
+#pragma region F16 Floats
 
 /**
  *  @brief  Compute the packed buffer size for f16 GEMM (B stored as f32).
@@ -1261,11 +1314,11 @@ NK_PUBLIC void nk_dots_symmetric_bf16_rvv(nk_bf16_t const *vectors, nk_size_t n_
  *  Layout: column-panel with depth-contiguous f32 values, cache-line padding.
  */
 NK_PUBLIC nk_size_t nk_dots_packed_size_f16_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     // Break power-of-2 strides for cache associativity
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f32_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -1278,10 +1331,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_f16_rvv(nk_size_t column_count, nk_size_
  */
 NK_PUBLIC void nk_dots_pack_f16_rvv(nk_f16_t const *b, nk_size_t column_count, nk_size_t depth,
                                     nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -1290,7 +1343,15 @@ NK_PUBLIC void nk_dots_pack_f16_rvv(nk_f16_t const *b, nk_size_t column_count, n
 
     nk_f32_t *packed = (nk_f32_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f32_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_f16_t const *src = (nk_f16_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -1346,11 +1407,11 @@ NK_INTERNAL void nk_dots_packed_f16_rvv_aligned_(nk_f16_t const *a_matrix, void
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_2_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_3_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -1379,13 +1440,13 @@ NK_INTERNAL void nk_dots_packed_f16_rvv_aligned_(nk_f16_t const *a_matrix, void
             // Horizontal reduce and narrow to f32
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
             c_row_2[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_2_f64m4, zero_f64m1, max_vector_length));
             c_row_3[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_3_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows (mr < 4)
@@ -1394,8 +1455,8 @@ NK_INTERNAL void nk_dots_packed_f16_rvv_aligned_(nk_f16_t const *a_matrix, void
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1408,7 +1469,7 @@ NK_INTERNAL void nk_dots_packed_f16_rvv_aligned_(nk_f16_t const *a_matrix, void
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -1419,9 +1480,10 @@ NK_INTERNAL void nk_dots_packed_f16_rvv_aligned_(nk_f16_t const *a_matrix, void
  *  Dispatches to the aligned kernel for all cases — RVV's `vsetvl` handles partial
  *  vectors naturally, so no separate edge kernel is needed.
  */
-NK_PUBLIC void nk_dots_packed_f16_rvv(nk_f16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                      nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_f16_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_f16_rvv(nk_f16_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                      nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                      nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_f16_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -1432,18 +1494,18 @@ NK_PUBLIC void nk_dots_packed_f16_rvv(nk_f16_t const *a, void const *b_packed, n
  *  Stride is in bytes.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_f16_rvv(nk_f16_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                         nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_f16_rvv(nk_f16_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                         nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                          nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u16_t const *a_i = (nk_u16_t const *)((char const *)vectors + i * stride);
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u16_t const *a_j = (nk_u16_t const *)((char const *)vectors + j * stride);
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+        nk_u16_t const *a_i = (nk_u16_t const *)((char const *)vectors + i * stride_in_bytes);
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u16_t const *a_j = (nk_u16_t const *)((char const *)vectors + j * stride_in_bytes);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1457,15 +1519,15 @@ NK_PUBLIC void nk_dots_symmetric_f16_rvv(nk_f16_t const *vectors, nk_size_t n_ve
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Half Precision Floats
+#pragma endregion F16 Floats
 
-#pragma region Signed 8-bit Integers
+#pragma region I8 Integers
 
 /**
  *  @brief  Compute the packed buffer size for i8 GEMM (B stored as i8).
@@ -1474,11 +1536,11 @@ NK_PUBLIC void nk_dots_symmetric_f16_rvv(nk_f16_t const *vectors, nk_size_t n_ve
  *  Layout: column-panel with depth-contiguous i8 values, cache-line padding.
  */
 NK_PUBLIC nk_size_t nk_dots_packed_size_i8_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     // Break power-of-2 strides for cache associativity
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_i8_t) +
            column_count * sizeof(nk_u32_t); // per-column norms
 }
@@ -1491,10 +1553,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_i8_rvv(nk_size_t column_count, nk_size_t
  */
 NK_PUBLIC void nk_dots_pack_i8_rvv(nk_i8_t const *b, nk_size_t column_count, nk_size_t depth,
                                    nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_i8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -1503,12 +1565,25 @@ NK_PUBLIC void nk_dots_pack_i8_rvv(nk_i8_t const *b, nk_size_t column_count, nk_
 
     nk_i8_t *packed = (nk_i8_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_i8_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_i8_t const *src = (nk_i8_t const *)((char const *)b + column * b_stride_in_bytes);
         nk_i8_t *dst = packed + column * depth_padded;
-        for (nk_size_t k = 0; k < depth; ++k) dst[k] = src[k];
+        for (nk_size_t k = 0; k < depth;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(depth - k);
+            __riscv_vse8_v_u8m8((nk_u8_t *)(dst + k), __riscv_vle8_v_u8m8((nk_u8_t const *)(src + k), vector_length),
+                                vector_length);
+            k += vector_length;
+        }
     }
 
     // Append per-column norms after packed data
@@ -1524,7 +1599,7 @@ NK_PUBLIC void nk_dots_pack_i8_rvv(nk_i8_t const *b, nk_size_t column_count, nk_
  *
  *  Vectorizes over the depth dimension (k). For each (row, column) pair:
  *    - Load i8 values from A and pre-packed i8 values from B
- *    - Widening multiply: i8 x i8 -> i16 via `vwmul`
+ *    - Widening multiply: i8 × i8 → i16 via `vwmul`
  *    - Widen-accumulate: i32 += i16 via `vwadd_wv`
  *    - Horizontal reduce via `vredsum`
  *
@@ -1560,11 +1635,11 @@ NK_INTERNAL void nk_dots_packed_i8_rvv_aligned_(nk_i8_t const *a_matrix, void co
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_2_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
-            vint32m4_t accumulator_3_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_0_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_1_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_2_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
+            vint32m4_t accumulator_3_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -1592,13 +1667,13 @@ NK_INTERNAL void nk_dots_packed_i8_rvv_aligned_(nk_i8_t const *a_matrix, void co
             // Horizontal reduce
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row_0[column] = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_0_i32m4, zero_i32m1, max_vector_length));
             c_row_1[column] = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_1_i32m4, zero_i32m1, max_vector_length));
             c_row_2[column] = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_2_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_2_i32m4, zero_i32m1, max_vector_length));
             c_row_3[column] = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_3_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_3_i32m4, zero_i32m1, max_vector_length));
         }
     }
     // Remainder rows (mr < 4)
@@ -1607,8 +1682,8 @@ NK_INTERNAL void nk_dots_packed_i8_rvv_aligned_(nk_i8_t const *a_matrix, void co
         nk_i32_t *c_row = (nk_i32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_i8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1621,7 +1696,7 @@ NK_INTERNAL void nk_dots_packed_i8_rvv_aligned_(nk_i8_t const *a_matrix, void co
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             c_row[column] = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length));
         }
     }
 }
@@ -1632,31 +1707,32 @@ NK_INTERNAL void nk_dots_packed_i8_rvv_aligned_(nk_i8_t const *a_matrix, void co
  *  Dispatches to the aligned kernel for all cases — RVV's `vsetvl` handles partial
  *  vectors naturally, so no separate edge kernel is needed.
  */
-NK_PUBLIC void nk_dots_packed_i8_rvv(nk_i8_t const *a, void const *b_packed, nk_i32_t *c, nk_size_t m, nk_size_t n,
-                                     nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_i8_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_i8_rvv(nk_i8_t const *a, void const *b_packed, nk_i32_t *c, nk_size_t rows,
+                                     nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                     nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_i8_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
  *  @brief  Symmetric i8 GEMM: C = A * A^T, upper triangle + mirror.
  *
  *  Uses integer i8 arithmetic with i32 accumulation.
- *  Both inputs are i8, widened via i8 x i8 -> i16 -> i32 accumulation.
+ *  Both inputs are i8, widened via i8 × i8 → i16 → i32 accumulation.
  *  Stride is in bytes.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_i8_rvv(nk_i8_t const *vectors, nk_size_t n_vectors, nk_size_t depth, nk_size_t stride,
-                                        nk_i32_t *result, nk_size_t result_stride, nk_size_t row_start,
-                                        nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_i32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+NK_PUBLIC void nk_dots_symmetric_i8_rvv(nk_i8_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                        nk_size_t stride_in_bytes, nk_i32_t *result, nk_size_t result_stride_in_bytes,
+                                        nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_i32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_i8_t const *a_i = (nk_i8_t const *)((char const *)vectors + i * stride);
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_i8_t const *a_j = (nk_i8_t const *)((char const *)vectors + j * stride);
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, vlmax);
+        nk_i8_t const *a_i = (nk_i8_t const *)((char const *)vectors + i * stride_in_bytes);
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_i8_t const *a_j = (nk_i8_t const *)((char const *)vectors + j * stride_in_bytes);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vint32m4_t accumulator_i32m4 = __riscv_vmv_v_x_i32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1669,15 +1745,15 @@ NK_PUBLIC void nk_dots_symmetric_i8_rvv(nk_i8_t const *vectors, nk_size_t n_vect
             }
             vint32m1_t zero_i32m1 = __riscv_vmv_v_x_i32m1(0, 1);
             nk_i32_t dot = (nk_i32_t)__riscv_vmv_x_s_i32m1_i32(
-                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, vlmax));
+                __riscv_vredsum_vs_i32m4_i32m1(accumulator_i32m4, zero_i32m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Signed 8-bit Integers
+#pragma endregion I8 Integers
 
-#pragma region Unsigned 8-bit Integers
+#pragma region U8 Integers
 
 /**
  *  @brief  Compute the packed buffer size for u8 GEMM (B stored as u8).
@@ -1686,11 +1762,11 @@ NK_PUBLIC void nk_dots_symmetric_i8_rvv(nk_i8_t const *vectors, nk_size_t n_vect
  *  Layout: column-panel with depth-contiguous u8 values, cache-line padding.
  */
 NK_PUBLIC nk_size_t nk_dots_packed_size_u8_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     // Break power-of-2 strides for cache associativity
     nk_size_t stride_bytes = depth_padded * sizeof(nk_u8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_u8_t) +
            column_count * sizeof(nk_u32_t); // per-column norms
 }
@@ -1703,10 +1779,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_u8_rvv(nk_size_t column_count, nk_size_t
  */
 NK_PUBLIC void nk_dots_pack_u8_rvv(nk_u8_t const *b, nk_size_t column_count, nk_size_t depth,
                                    nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e8m1();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e8m1();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_u8_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -1715,12 +1791,24 @@ NK_PUBLIC void nk_dots_pack_u8_rvv(nk_u8_t const *b, nk_size_t column_count, nk_
 
     nk_u8_t *packed = (nk_u8_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_u8_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_u8_t const *src = (nk_u8_t const *)((char const *)b + column * b_stride_in_bytes);
         nk_u8_t *dst = packed + column * depth_padded;
-        for (nk_size_t k = 0; k < depth; ++k) dst[k] = src[k];
+        for (nk_size_t k = 0; k < depth;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(depth - k);
+            __riscv_vse8_v_u8m8(dst + k, __riscv_vle8_v_u8m8(src + k, vector_length), vector_length);
+            k += vector_length;
+        }
     }
 
     // Append per-column norms after packed data
@@ -1736,7 +1824,7 @@ NK_PUBLIC void nk_dots_pack_u8_rvv(nk_u8_t const *b, nk_size_t column_count, nk_
  *
  *  Vectorizes over the depth dimension (k). For each (row, column) pair:
  *    - Load u8 values from A and pre-packed u8 values from B
- *    - Widening multiply: u8 x u8 -> u16 via `vwmulu`
+ *    - Widening multiply: u8 × u8 → u16 via `vwmulu`
  *    - Widen-accumulate: u32 += u16 via `vwaddu_wv`
  *    - Horizontal reduce via `vredsum`
  *
@@ -1772,11 +1860,11 @@ NK_INTERNAL void nk_dots_packed_u8_rvv_aligned_(nk_u8_t const *a_matrix, void co
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_u8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vuint32m4_t accumulator_0_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
-            vuint32m4_t accumulator_1_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
-            vuint32m4_t accumulator_2_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
-            vuint32m4_t accumulator_3_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vuint32m4_t accumulator_0_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
+            vuint32m4_t accumulator_1_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
+            vuint32m4_t accumulator_2_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
+            vuint32m4_t accumulator_3_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -1804,13 +1892,13 @@ NK_INTERNAL void nk_dots_packed_u8_rvv_aligned_(nk_u8_t const *a_matrix, void co
             // Horizontal reduce
             vuint32m1_t zero_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
             c_row_0[column] = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_0_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_0_u32m4, zero_u32m1, max_vector_length));
             c_row_1[column] = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_1_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_1_u32m4, zero_u32m1, max_vector_length));
             c_row_2[column] = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_2_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_2_u32m4, zero_u32m1, max_vector_length));
             c_row_3[column] = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_3_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_3_u32m4, zero_u32m1, max_vector_length));
         }
     }
     // Remainder rows (mr < 4)
@@ -1819,8 +1907,8 @@ NK_INTERNAL void nk_dots_packed_u8_rvv_aligned_(nk_u8_t const *a_matrix, void co
         nk_u32_t *c_row = (nk_u32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_u8_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vuint32m4_t accumulator_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vuint32m4_t accumulator_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1833,7 +1921,7 @@ NK_INTERNAL void nk_dots_packed_u8_rvv_aligned_(nk_u8_t const *a_matrix, void co
             }
             vuint32m1_t zero_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
             c_row[column] = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_u32m4, zero_u32m1, max_vector_length));
         }
     }
 }
@@ -1844,31 +1932,32 @@ NK_INTERNAL void nk_dots_packed_u8_rvv_aligned_(nk_u8_t const *a_matrix, void co
  *  Dispatches to the aligned kernel for all cases — RVV's `vsetvl` handles partial
  *  vectors naturally, so no separate edge kernel is needed.
  */
-NK_PUBLIC void nk_dots_packed_u8_rvv(nk_u8_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t m, nk_size_t n,
-                                     nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_u8_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_u8_rvv(nk_u8_t const *a, void const *b_packed, nk_u32_t *c, nk_size_t rows,
+                                     nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                     nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_u8_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
  *  @brief  Symmetric u8 GEMM: C = A * A^T, upper triangle + mirror.
  *
  *  Uses unsigned integer u8 arithmetic with u32 accumulation.
- *  Both inputs are u8, widened via u8 x u8 -> u16 -> u32 accumulation.
+ *  Both inputs are u8, widened via u8 × u8 → u16 → u32 accumulation.
  *  Stride is in bytes.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_u8_rvv(nk_u8_t const *vectors, nk_size_t n_vectors, nk_size_t depth, nk_size_t stride,
-                                        nk_u32_t *result, nk_size_t result_stride, nk_size_t row_start,
-                                        nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_u32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+NK_PUBLIC void nk_dots_symmetric_u8_rvv(nk_u8_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                        nk_size_t stride_in_bytes, nk_u32_t *result, nk_size_t result_stride_in_bytes,
+                                        nk_size_t row_start, nk_size_t row_count) {
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_u32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u8_t const *a_i = (nk_u8_t const *)((char const *)vectors + i * stride);
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u8_t const *a_j = (nk_u8_t const *)((char const *)vectors + j * stride);
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m4();
-            vuint32m4_t accumulator_u32m4 = __riscv_vmv_v_x_u32m4(0, vlmax);
+        nk_u8_t const *a_i = (nk_u8_t const *)((char const *)vectors + i * stride_in_bytes);
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u8_t const *a_j = (nk_u8_t const *)((char const *)vectors + j * stride_in_bytes);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m4();
+            vuint32m4_t accumulator_u32m4 = __riscv_vmv_v_x_u32m4(0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -1881,18 +1970,18 @@ NK_PUBLIC void nk_dots_symmetric_u8_rvv(nk_u8_t const *vectors, nk_size_t n_vect
             }
             vuint32m1_t zero_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
             nk_u32_t dot = (nk_u32_t)__riscv_vmv_x_s_u32m1_u32(
-                __riscv_vredsum_vs_u32m4_u32m1(accumulator_u32m4, zero_u32m1, vlmax));
+                __riscv_vredsum_vs_u32m4_u32m1(accumulator_u32m4, zero_u32m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Unsigned 8-bit Integers
+#pragma endregion U8 Integers
 
-#pragma region Quarter Precision E4M3
+#pragma region E4M3 Floats
 
 /**
- *  @brief  E4M3 magnitude LUT: 7-bit magnitude -> f32 bit pattern (u32).
+ *  @brief  E4M3 magnitude LUT: 7-bit magnitude → f32 bit pattern (u32).
  *          nk_e4m3_magnitude_lut_rvv_[i] = float_to_bits(e4m3_to_f32(i)) for i=0..127.
  *          E4M3FN: 4 exponent bits (bias=7), 3 mantissa bits, no infinity,
  *          NaN = magnitude 0x7F only.
@@ -1933,10 +2022,10 @@ static nk_u32_t const nk_e4m3_magnitude_lut_rvv_[128] = {
 };
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_e4m3_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f32_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -1949,10 +2038,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e4m3_rvv(nk_size_t column_count, nk_size
  */
 NK_PUBLIC void nk_dots_pack_e4m3_rvv(nk_e4m3_t const *b, nk_size_t column_count, nk_size_t depth,
                                      nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -1961,7 +2050,15 @@ NK_PUBLIC void nk_dots_pack_e4m3_rvv(nk_e4m3_t const *b, nk_size_t column_count,
 
     nk_f32_t *packed = (nk_f32_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f32_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_e4m3_t const *src = (nk_e4m3_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -1985,7 +2082,7 @@ NK_PUBLIC void nk_dots_pack_e4m3_rvv(nk_e4m3_t const *b, nk_size_t column_count,
  *    - Load raw e4m3 bytes from A, convert on-the-fly via 128-entry f32 LUT gather:
  *      extract 7-bit magnitude, zero-extend to u32, compute byte offsets (x4),
  *      gather f32 bit patterns, inject sign bit from bit 7 (<<24), reinterpret as f32
- *    - Widening FMA: f32xf32 -> f64 via `vfwmacc_vv_f64m4`
+ *    - Widening FMA: f32xf32 → f64 via `vfwmacc_vv_f64m4`
  *
  *  Register tile: process 2 rows per iteration (rows_per_tile=2, u32m2 gather + f64m4 accumulator is register-heavy).
  */
@@ -2014,9 +2111,9 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -2059,7 +2156,7 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
                 vfloat32m2_t a_vector_1_f32m2 = __riscv_vreinterpret_v_u32m2_f32m2(
                     __riscv_vor_vv_u32m2(bits1_u32m2, sign1_u32m2, vector_length));
 
-                // Widening FMA: f32xf32 -> f64
+                // Widening FMA: f32xf32 → f64
                 accumulator_0_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_0_f64m4, a_vector_0_f32m2, b_vector_f32m2,
                                                                   vector_length);
                 accumulator_1_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_1_f64m4, a_vector_1_f32m2, b_vector_f32m2,
@@ -2069,9 +2166,9 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
             // Horizontal reduce and narrow to f32
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows
@@ -2080,8 +2177,8 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -2103,7 +2200,7 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -2111,9 +2208,10 @@ NK_INTERNAL void nk_dots_packed_e4m3_rvv_aligned_(nk_e4m3_t const *a_matrix, voi
 /**
  *  @brief  Public e4m3 packed GEMM wrapper matching the declared signature in dots.h.
  */
-NK_PUBLIC void nk_dots_packed_e4m3_rvv(nk_e4m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                       nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_e4m3_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_e4m3_rvv(nk_e4m3_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                       nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                       nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_e4m3_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -2123,18 +2221,18 @@ NK_PUBLIC void nk_dots_packed_e4m3_rvv(nk_e4m3_t const *a, void const *b_packed,
  *  Both operands are converted from e4m3 on-the-fly via magnitude LUT.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_e4m3_rvv(nk_e4m3_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                          nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_e4m3_rvv(nk_e4m3_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                           nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride_in_bytes;
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride_in_bytes;
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -2166,24 +2264,24 @@ NK_PUBLIC void nk_dots_symmetric_e4m3_rvv(nk_e4m3_t const *vectors, nk_size_t n_
                 vfloat32m2_t val_j_f32m2 = __riscv_vreinterpret_v_u32m2_f32m2(
                     __riscv_vor_vv_u32m2(bits_j_u32m2, sign_j_u32m2, vector_length));
 
-                // Widening FMA: f32xf32 -> f64
+                // Widening FMA: f32xf32 → f64
                 accumulator_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_f64m4, val_i_f32m2, val_j_f32m2,
                                                                 vector_length);
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Quarter Precision E4M3
+#pragma endregion E4M3 Floats
 
-#pragma region Quarter Precision E5M2
+#pragma region E5M2 Floats
 
 /**
- *  @brief  E5M2 magnitude LUT: 7-bit magnitude -> f32 bit pattern (u32).
+ *  @brief  E5M2 magnitude LUT: 7-bit magnitude → f32 bit pattern (u32).
  *          nk_e5m2_magnitude_lut_rvv_[i] = float_to_bits(e5m2_to_f32(i)) for i=0..127.
  *          E5M2: 5 exponent bits (bias=15), 2 mantissa bits, has infinity (0x7C) and
  *          NaN (magnitudes 0x7D..0x7F).
@@ -2224,10 +2322,10 @@ static nk_u32_t const nk_e5m2_magnitude_lut_rvv_[128] = {
 };
 
 NK_PUBLIC nk_size_t nk_dots_packed_size_e5m2_rvv(nk_size_t column_count, nk_size_t depth) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
     return sizeof(nk_cross_packed_buffer_header_t) + column_count * depth_padded * sizeof(nk_f32_t) +
            column_count * sizeof(nk_f32_t); // per-column norms
 }
@@ -2240,10 +2338,10 @@ NK_PUBLIC nk_size_t nk_dots_packed_size_e5m2_rvv(nk_size_t column_count, nk_size
  */
 NK_PUBLIC void nk_dots_pack_e5m2_rvv(nk_e5m2_t const *b, nk_size_t column_count, nk_size_t depth,
                                      nk_size_t b_stride_in_bytes, void *b_packed) {
-    nk_size_t vector_length = __riscv_vsetvlmax_e32m2();
-    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, vector_length);
+    nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+    nk_size_t depth_padded = nk_size_round_up_to_multiple_(depth, max_vector_length);
     nk_size_t stride_bytes = depth_padded * sizeof(nk_f32_t);
-    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += vector_length;
+    if (stride_bytes > 0 && (stride_bytes & (stride_bytes - 1)) == 0) depth_padded += max_vector_length;
 
     nk_cross_packed_buffer_header_t *header = (nk_cross_packed_buffer_header_t *)b_packed;
     header->column_count = (nk_u32_t)column_count;
@@ -2252,7 +2350,15 @@ NK_PUBLIC void nk_dots_pack_e5m2_rvv(nk_e5m2_t const *b, nk_size_t column_count,
 
     nk_f32_t *packed = (nk_f32_t *)((char *)b_packed + sizeof(nk_cross_packed_buffer_header_t));
     nk_size_t total = column_count * depth_padded;
-    for (nk_size_t i = 0; i < total; ++i) packed[i] = 0;
+    {
+        nk_u8_t *zero_ptr = (nk_u8_t *)packed;
+        nk_size_t total_bytes = total * sizeof(nk_f32_t);
+        for (nk_size_t i = 0; i < total_bytes;) {
+            nk_size_t vector_length = __riscv_vsetvl_e8m8(total_bytes - i);
+            __riscv_vse8_v_u8m8(zero_ptr + i, __riscv_vmv_v_x_u8m8(0, vector_length), vector_length);
+            i += vector_length;
+        }
+    }
 
     for (nk_size_t column = 0; column < column_count; ++column) {
         nk_e5m2_t const *src = (nk_e5m2_t const *)((char const *)b + column * b_stride_in_bytes);
@@ -2276,7 +2382,7 @@ NK_PUBLIC void nk_dots_pack_e5m2_rvv(nk_e5m2_t const *b, nk_size_t column_count,
  *    - Load raw e5m2 bytes from A, convert on-the-fly via 128-entry f32 LUT gather:
  *      extract 7-bit magnitude, zero-extend to u32, compute byte offsets (x4),
  *      gather f32 bit patterns, inject sign bit from bit 7 (<<24), reinterpret as f32
- *    - Widening FMA: f32xf32 -> f64 via `vfwmacc_vv_f64m4`
+ *    - Widening FMA: f32xf32 → f64 via `vfwmacc_vv_f64m4`
  *
  *  Register tile: process 2 rows per iteration (rows_per_tile=2, u32m2 gather + f64m4 accumulator is register-heavy).
  */
@@ -2305,9 +2411,9 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
 
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
-            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_0_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
+            vfloat64m4_t accumulator_1_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
 
             nk_size_t remaining = depth;
             nk_size_t k = 0;
@@ -2350,7 +2456,7 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
                 vfloat32m2_t a_vector_1_f32m2 = __riscv_vreinterpret_v_u32m2_f32m2(
                     __riscv_vor_vv_u32m2(bits1_u32m2, sign1_u32m2, vector_length));
 
-                // Widening FMA: f32xf32 -> f64
+                // Widening FMA: f32xf32 → f64
                 accumulator_0_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_0_f64m4, a_vector_0_f32m2, b_vector_f32m2,
                                                                   vector_length);
                 accumulator_1_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_1_f64m4, a_vector_1_f32m2, b_vector_f32m2,
@@ -2360,9 +2466,9 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
             // Horizontal reduce and narrow to f32
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row_0[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_0_f64m4, zero_f64m1, max_vector_length));
             c_row_1[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_1_f64m4, zero_f64m1, max_vector_length));
         }
     }
     // Remainder rows
@@ -2371,8 +2477,8 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
         nk_f32_t *c_row = (nk_f32_t *)((char *)c_matrix + row * c_stride_in_bytes);
         for (nk_size_t column = 0; column < column_count; ++column) {
             nk_f32_t const *b_column = packed_data + column * depth_padded;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -2394,7 +2500,7 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             c_row[column] = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
         }
     }
 }
@@ -2402,9 +2508,10 @@ NK_INTERNAL void nk_dots_packed_e5m2_rvv_aligned_(nk_e5m2_t const *a_matrix, voi
 /**
  *  @brief  Public e5m2 packed GEMM wrapper matching the declared signature in dots.h.
  */
-NK_PUBLIC void nk_dots_packed_e5m2_rvv(nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t m, nk_size_t n,
-                                       nk_size_t k, nk_size_t a_stride, nk_size_t c_stride) {
-    nk_dots_packed_e5m2_rvv_aligned_(a, b_packed, c, m, n, k, a_stride, c_stride);
+NK_PUBLIC void nk_dots_packed_e5m2_rvv(nk_e5m2_t const *a, void const *b_packed, nk_f32_t *c, nk_size_t rows,
+                                       nk_size_t columns, nk_size_t depth, nk_size_t a_stride_in_bytes,
+                                       nk_size_t c_stride_in_bytes) {
+    nk_dots_packed_e5m2_rvv_aligned_(a, b_packed, c, rows, columns, depth, a_stride_in_bytes, c_stride_in_bytes);
 }
 
 /**
@@ -2414,18 +2521,18 @@ NK_PUBLIC void nk_dots_packed_e5m2_rvv(nk_e5m2_t const *a, void const *b_packed,
  *  Both operands are converted from e5m2 on-the-fly via magnitude LUT.
  *  Processes only the rows in [row_start, row_start + row_count) for parallelism.
  */
-NK_PUBLIC void nk_dots_symmetric_e5m2_rvv(nk_e5m2_t const *vectors, nk_size_t n_vectors, nk_size_t depth,
-                                          nk_size_t stride, nk_f32_t *result, nk_size_t result_stride,
+NK_PUBLIC void nk_dots_symmetric_e5m2_rvv(nk_e5m2_t const *vectors, nk_size_t vectors_count, nk_size_t depth,
+                                          nk_size_t stride_in_bytes, nk_f32_t *result, nk_size_t result_stride_in_bytes,
                                           nk_size_t row_start, nk_size_t row_count) {
-    nk_size_t const result_stride_elements = result_stride / sizeof(nk_f32_t);
-    nk_size_t const row_end = (row_start + row_count < n_vectors) ? (row_start + row_count) : n_vectors;
+    nk_size_t const result_stride_elements = result_stride_in_bytes / sizeof(nk_f32_t);
+    nk_size_t const row_end = (row_start + row_count < vectors_count) ? (row_start + row_count) : vectors_count;
 
     for (nk_size_t i = row_start; i < row_end; ++i) {
-        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride;
-        for (nk_size_t j = i; j < n_vectors; ++j) {
-            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride;
-            nk_size_t vlmax = __riscv_vsetvlmax_e32m2();
-            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, vlmax);
+        nk_u8_t const *a_i = (nk_u8_t const *)vectors + i * stride_in_bytes;
+        for (nk_size_t j = i; j < vectors_count; ++j) {
+            nk_u8_t const *a_j = (nk_u8_t const *)vectors + j * stride_in_bytes;
+            nk_size_t max_vector_length = __riscv_vsetvlmax_e32m2();
+            vfloat64m4_t accumulator_f64m4 = __riscv_vfmv_v_f_f64m4(0.0, max_vector_length);
             nk_size_t remaining = depth;
             nk_size_t k = 0;
             for (nk_size_t vector_length = 0; remaining > 0; remaining -= vector_length, k += vector_length) {
@@ -2457,19 +2564,19 @@ NK_PUBLIC void nk_dots_symmetric_e5m2_rvv(nk_e5m2_t const *vectors, nk_size_t n_
                 vfloat32m2_t val_j_f32m2 = __riscv_vreinterpret_v_u32m2_f32m2(
                     __riscv_vor_vv_u32m2(bits_j_u32m2, sign_j_u32m2, vector_length));
 
-                // Widening FMA: f32xf32 -> f64
+                // Widening FMA: f32xf32 → f64
                 accumulator_f64m4 = __riscv_vfwmacc_vv_f64m4_tu(accumulator_f64m4, val_i_f32m2, val_j_f32m2,
                                                                 vector_length);
             }
             vfloat64m1_t zero_f64m1 = __riscv_vfmv_v_f_f64m1(0.0, 1);
             nk_f32_t dot = (nk_f32_t)__riscv_vfmv_f_s_f64m1_f64(
-                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, vlmax));
+                __riscv_vfredusum_vs_f64m4_f64m1(accumulator_f64m4, zero_f64m1, max_vector_length));
             result[i * result_stride_elements + j] = dot;
         }
     }
 }
 
-#pragma endregion // Quarter Precision E5M2
+#pragma endregion E5M2 Floats
 
 #if defined(__cplusplus)
 } // extern "C"