diff --git a/softrvv/include/softrvv.h b/softrvv/include/softrvv.h
index 30326c1..0ab210f 100644
--- a/softrvv/include/softrvv.h
+++ b/softrvv/include/softrvv.h
@@ -6,6 +6,7 @@
 #include "encoding.h"
 #include "softrvv_vadd.h"
 #include "softrvv_vdiv.h"
+#include "softrvv_vmax.h"
 #include "softrvv_vmin.h"
 #include "softrvv_vmul_vmulh.h"
 #include "softrvv_vor.h"
diff --git a/softrvv/include/softrvv_vmax.h b/softrvv/include/softrvv_vmax.h
new file mode 100644
index 0000000..5ad4352
--- /dev/null
+++ b/softrvv/include/softrvv_vmax.h
@@ -0,0 +1,25 @@
+#ifndef SOFTRVV_VMAX_H
+#define SOFTRVV_VMAX_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace softrvv {
+
+template <typename T>
+void vmax_vx(T *dest, T *src1, const T *src2, int32_t avl) {
+  for (int32_t idx = 0; idx < avl; idx++) {
+    dest[idx] = (src1[idx] > *src2) ? src1[idx] : *src2;
+  }
+}
+
+template <typename T>
+void vmax_vv(T *dest, T *src1, T *src2, int32_t avl) {
+  for (int32_t idx = 0; idx < avl; idx++) {
+    dest[idx] = (src1[idx] > src2[idx]) ? src1[idx] : src2[idx];
+  }
+}
+
+}  // namespace softrvv
+
+#endif  // SOFTRVV_VMAX_H
diff --git a/softrvv/tests/CMakeLists.txt b/softrvv/tests/CMakeLists.txt
index 6fc4a44..221e353 100644
--- a/softrvv/tests/CMakeLists.txt
+++ b/softrvv/tests/CMakeLists.txt
@@ -160,3 +160,25 @@
   LINKOPTS
    -Xlinker --defsym=__itcm_length__=128K
 )
+
+vec_cc_test(
+  NAME
+    softrvv_vmax
+  SRCS
+    softrvv_vmax_test.cpp
+  DEPS
+    softrvv
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+)
+
+vec_cc_test(
+  NAME
+    softrvv_vmaxu
+  SRCS
+    softrvv_vmaxu_test.cpp
+  DEPS
+    softrvv
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+)
diff --git a/softrvv/tests/softrvv_vmax_test.cpp b/softrvv/tests/softrvv_vmax_test.cpp
new file mode 100644
index 0000000..8b1e179
--- /dev/null
+++ b/softrvv/tests/softrvv_vmax_test.cpp
@@ -0,0 +1,48 @@
+#include <riscv_vector.h>
+#include <springbok.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "pw_unit_test/framework.h"
+#include "softrvv.h"
+
+namespace softrvv_vmax_test {
+namespace {
+
+// common to all tests
+int32_t src1[] = {-1, 2, 3, 4, 5};
+
+// vector test
+int32_t src2[] = {5, 4, 3, 2, -1};
+
+// scalar register tests
+int32_t rs1[] = {-1, 3, 5};
+
+};  // namespace
+const int32_t kAVL = sizeof(src1) / sizeof(src1[0]);
+int32_t dest[kAVL];
+
+int32_t ref_vv[] = {5, 4, 3, 4, 5};
+
+int32_t ref_vx[3][kAVL] = {{-1, 2, 3, 4, 5}, {3, 3, 3, 4, 5}, {5, 5, 5, 5, 5}};
+
+class SoftRvvVmaxTest : public ::testing::Test {
+ protected:
+  void SetUp() override { memset(dest, 0, sizeof(dest)); }
+};
+
+TEST_F(SoftRvvVmaxTest, VV) {
+  softrvv::vmax_vv<int32_t>(dest, src1, src2, kAVL);
+  ASSERT_EQ(memcmp(dest, ref_vv, sizeof(dest)), 0);
+}
+
+TEST_F(SoftRvvVmaxTest, VX) {
+  const int32_t num_vx_tests = sizeof(rs1) / sizeof(rs1[0]);
+  for (int32_t i = 0; i < num_vx_tests; i++) {
+    softrvv::vmax_vx<int32_t>(dest, src1, &rs1[i], kAVL);
+    ASSERT_EQ(memcmp(dest, &ref_vx[i], sizeof(dest)), 0);
+  }
+}
+
+}  // namespace softrvv_vmax_test
diff --git a/softrvv/tests/softrvv_vmaxu_test.cpp b/softrvv/tests/softrvv_vmaxu_test.cpp
new file mode 100644
index 0000000..cc7306b
--- /dev/null
+++ b/softrvv/tests/softrvv_vmaxu_test.cpp
@@ -0,0 +1,48 @@
+#include <riscv_vector.h>
+#include <springbok.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "pw_unit_test/framework.h"
+#include "softrvv.h"
+
+namespace softrvv_vmaxu_test {
+namespace {
+
+// common to all tests
+int32_t src1[] = {1, 2, 3, 4, 5};
+
+// vector test
+int32_t src2[] = {5, 4, 3, 2, 1};
+
+// scalar register tests
+int32_t rs1[] = {1, 3, 5};
+
+};  // namespace
+const int32_t kAVL = sizeof(src1) / sizeof(src1[0]);
+int32_t dest[kAVL];
+
+int32_t ref_vv[] = {5, 4, 3, 4, 5};
+
+int32_t ref_vx[3][kAVL] = {{1, 2, 3, 4, 5}, {3, 3, 3, 4, 5}, {5, 5, 5, 5, 5}};
+
+class SoftRvvVmaxuTest : public ::testing::Test {
+ protected:
+  void SetUp() override { memset(dest, 0, sizeof(dest)); }
+};
+
+TEST_F(SoftRvvVmaxuTest, VV) {
+  softrvv::vmax_vv<int32_t>(dest, src1, src2, kAVL);
+  ASSERT_EQ(memcmp(dest, ref_vv, sizeof(dest)), 0);
+}
+
+TEST_F(SoftRvvVmaxuTest, VX) {
+  const int32_t num_vx_tests = sizeof(rs1) / sizeof(rs1[0]);
+  for (int32_t i = 0; i < num_vx_tests; i++) {
+    softrvv::vmax_vx<int32_t>(dest, src1, &rs1[i], kAVL);
+    ASSERT_EQ(memcmp(dest, &ref_vx[i], sizeof(dest)), 0);
+  }
+}
+
+}  // namespace softrvv_vmaxu_test
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index d30cf2a..687aeb7 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -196,6 +196,26 @@
 
 vec_cc_generated_test(
   NAME
+    vmax
+  OPFMT
+    OPIVV
+    OPIVX
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+)
+
+vec_cc_generated_test(
+  NAME
+    vmaxu
+  OPFMT
+    OPIVV
+    OPIVX
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+)
+
+vec_cc_generated_test(
+  NAME
     vsext
   OPFMT
     VXUNARY0
@@ -242,15 +262,3 @@
   TIMEOUT
     40
 )
-
-vec_cc_test(
-  NAME
-    vmax_test
-  SRCS
-    vmax_vx_test.cpp
-    vmax_vv_test.cpp
-  LINKOPTS
-   -Xlinker --defsym=__itcm_length__=128K
-  TIMEOUT
-    40
-)
diff --git a/tests/vmax_vv_test.cpp b/tests/vmax_vv_test.cpp
deleted file mode 100644
index f4183ec..0000000
--- a/tests/vmax_vv_test.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include <limits.h>
-#include <riscv_vector.h>
-#include <springbok.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <bit>
-#include <tuple>
-
-#include "pw_unit_test/framework.h"
-#include "test_v_helpers.h"
-
-namespace vmax_vv_test {
-namespace {
-
-using namespace test_v_helpers;
-
-uint8_t test_vector_1[MAXVL_BYTES];
-uint8_t test_vector_2[MAXVL_BYTES];
-
-template <typename T>
-static std::tuple<int, int> vmax_vv_test_setup(VLMUL lmul, int32_t avl) {
-  // Clear all vector registers
-  zero_vector_registers();
-
-  // Initialize test_vector_1 and determine vl, vlmax
-  uint32_t bw = std::__bit_width(sizeof(T));
-  VSEW sew = static_cast<VSEW>(bw - 1);
-  int vlmax = get_vsetvlmax_intrinsic(sew, lmul);
-  if (avl > vlmax) {
-    avl = vlmax;
-  }
-  memset(test_vector_1, 0, MAXVL_BYTES);
-  memset(test_vector_2, 0, MAXVL_BYTES);
-  int vl = set_vsetvl_intrinsic(sew, lmul, avl);
-  EXPECT_EQ(avl, vl);
-
-  return std::make_tuple(vlmax, vl);
-}
-
-class VmaxVvTest : public ::testing::Test {
- protected:
-  void SetUp() override { zero_vector_registers(); }
-  void TearDown() override { zero_vector_registers(); }
-};
-
-// Below is a non-macro version of the test for more convenient debugging.
-// Remove the "DISABLED_" prefix to enable this test for debugging.
-TEST_F(VmaxVvTest, DISABLED_vmax_vv_demo) {
-  for (int i = 0; i < AVL_COUNT; i++) {
-    int32_t avl = AVLS[i];
-    int vlmax;
-    int vl;
-    std::tie(vlmax, vl) = vmax_vv_test_setup<int16_t>(VLMUL::LMUL_M1, avl);
-    if (avl > vlmax) {
-      continue;
-    }
-    int16_t *ptr_vec_1 = reinterpret_cast<int16_t *>(test_vector_1);
-    int16_t *ptr_vec_2 = reinterpret_cast<int16_t *>(test_vector_2);
-
-    const int16_t start_value = INT16_MAX;
-
-    // set up values for vs2 of vmax.vv
-    for (int idx = 0; idx < vl; idx++) {
-      // restrict values to valid int8_t range
-      ptr_vec_1[idx] = (int16_t)(idx + start_value);
-    }
-
-    __asm__ volatile("vle16.v v8, (%0)" : : "r"(ptr_vec_1));
-
-    // set up values for vs2 of vmax.vv
-    for (int idx = 0; idx < vl; idx++) {
-      // offset sequence for ptr_vec_2
-      ptr_vec_2[idx] = (int16_t)(idx - start_value);
-    }
-
-    __asm__ volatile("vle16.v v16, (%0)" : : "r"(ptr_vec_2));
-
-    __asm__ volatile("vmax.vv v24, v16, v8");
-
-    // emulate operation in C
-    for (int idx = 0; idx < vl; idx++) {
-      ptr_vec_1[idx] =
-          (ptr_vec_1[idx] > ptr_vec_2[idx]) ? ptr_vec_1[idx] : ptr_vec_2[idx];
-    }
-
-    __asm__ volatile("vse16.v v24, (%0)" : : "r"(ptr_vec_2));
-    assert_vec_elem_eq<int16_t>(vlmax, test_vector_1, test_vector_2);
-  }
-}
-
-#define DEFINE_TEST_VMAX_VV(_SEW_, _LMUL_, START_VALUE)                        \
-  TEST_F(VmaxVvTest, vmax_vv##_SEW_##m##_LMUL_) {                              \
-    for (int i = 0; i < AVL_COUNT; i++) {                                      \
-      int32_t avl = AVLS[i];                                                   \
-      int vlmax;                                                               \
-      int vl;                                                                  \
-      std::tie(vlmax, vl) =                                                    \
-          vmax_vv_test_setup<int##_SEW_##_t>(VLMUL::LMUL_M##_LMUL_, avl);      \
-      if (avl > vlmax) {                                                       \
-        continue;                                                              \
-      }                                                                        \
-      int##_SEW_##_t *ptr_vec_1 =                                              \
-          reinterpret_cast<int##_SEW_##_t *>(test_vector_1);                   \
-      int##_SEW_##_t *ptr_vec_2 =                                              \
-          reinterpret_cast<int##_SEW_##_t *>(test_vector_2);                   \
-      const int##_SEW_##_t start_value = START_VALUE;                          \
-      for (int idx = 0; idx < vl; idx++) {                                     \
-        ptr_vec_1[idx] = (int##_SEW_##_t)(idx + start_value);                  \
-      }                                                                        \
-      for (int idx = 0; idx < vl; idx++) {                                     \
-        ptr_vec_1[idx] = (int##_SEW_##_t)(idx - start_value);                  \
-      }                                                                        \
-      __asm__ volatile("vle" #_SEW_ ".v v8, (%0)" : : "r"(ptr_vec_1));         \
-      __asm__ volatile("vle" #_SEW_ ".v v16, (%0)" : : "r"(ptr_vec_2));        \
-      __asm__ volatile("vmax.vv v24, v16, v8");                                \
-      for (int idx = 0; idx < vl; idx++) {                                     \
-        ptr_vec_1[idx] = (ptr_vec_1[idx] > ptr_vec_2[idx]) ? ptr_vec_1[idx]    \
-                                                           : ptr_vec_2[idx];   \
-      }                                                                        \
-      __asm__ volatile("vse" #_SEW_ ".v v24, (%0)" : : "r"(ptr_vec_2));        \
-      assert_vec_elem_eq<int##_SEW_##_t>(vlmax, test_vector_1, test_vector_2); \
-    }                                                                          \
-  }
-
-// TODO(gkielian): modify macro to permit more than one test per sew/lmul pair
-DEFINE_TEST_VMAX_VV(8, 1, INT8_MAX)
-DEFINE_TEST_VMAX_VV(8, 2, INT8_MIN)
-DEFINE_TEST_VMAX_VV(8, 4, 120)
-DEFINE_TEST_VMAX_VV(8, 8, 2)
-
-DEFINE_TEST_VMAX_VV(16, 1, INT16_MAX)
-DEFINE_TEST_VMAX_VV(16, 2, INT16_MIN)
-DEFINE_TEST_VMAX_VV(16, 4, 16000)
-DEFINE_TEST_VMAX_VV(16, 8, 2)
-
-DEFINE_TEST_VMAX_VV(32, 1, INT32_MAX)
-DEFINE_TEST_VMAX_VV(32, 2, INT32_MIN)
-DEFINE_TEST_VMAX_VV(32, 4, 1000000000)
-DEFINE_TEST_VMAX_VV(32, 8, 2)
-
-}  // namespace
-}  // namespace vmax_vv_test
diff --git a/tests/vmax_vx_test.cpp b/tests/vmax_vx_test.cpp
deleted file mode 100644
index 3dfed33..0000000
--- a/tests/vmax_vx_test.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include <limits.h>
-#include <riscv_vector.h>
-#include <springbok.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <bit>
-#include <tuple>
-
-#include "pw_unit_test/framework.h"
-#include "test_v_helpers.h"
-
-namespace vmax_vx_test {
-namespace {
-
-using namespace test_v_helpers;
-
-uint8_t test_vector_1[MAXVL_BYTES];
-uint8_t test_vector_2[MAXVL_BYTES];
-
-class VmaxVxTest : public ::testing::Test {
- protected:
-  void SetUp() override { zero_vector_registers(); }
-  void TearDown() override { zero_vector_registers(); }
-};
-
-// Below is a non-macro version of the test for more convenient debugging.
-// Remove the "DISABLED_" prefix to enable this test for debugging.
-TEST_F(VmaxVxTest, DISABLED_vmax_vx_demo) {
-  for (int i = 0; i < AVL_COUNT; i++) {
-    int32_t avl = AVLS[i];
-    int vlmax;
-    int vl;
-    std::tie(vlmax, vl) = vector_test_setup<uint8_t>(
-        VLMUL::LMUL_M1, avl, {test_vector_1, test_vector_2});
-    if (avl > vlmax) {
-      continue;
-    }
-    int8_t *ptr_vec_1 = reinterpret_cast<int8_t *>(test_vector_1);
-    int8_t *ptr_vec_2 = reinterpret_cast<int8_t *>(test_vector_2);
-    const int8_t test_val = 8;
-
-    for (int idx = 0; idx < vl; idx++) {
-      ptr_vec_1[idx] = idx;
-    }
-    __asm__ volatile("vle8.v v8, (%0)" : : "r"(ptr_vec_1));
-    __asm__ volatile("vmax.vx v16, v8, %[RS1]" ::[RS1] "r"(test_val));
-
-    for (int idx = 0; idx < vl; idx++) {
-      ptr_vec_1[idx] = (ptr_vec_1[idx] > test_val) ? ptr_vec_1[idx] : test_val;
-    }
-
-    __asm__ volatile("vse8.v v16, (%0)" : : "r"(ptr_vec_2));
-    assert_vec_elem_eq<int8_t>(vlmax, test_vector_1, test_vector_2);
-  }
-}
-
-#define DEFINE_TEST_VMAX_VX(_SEW_, _LMUL_, TEST_VAL)                           \
-  TEST_F(VmaxVxTest, vmax_vx##_SEW_##m##_LMUL_) {                              \
-    for (int i = 0; i < AVL_COUNT; i++) {                                      \
-      int32_t avl = AVLS[i];                                                   \
-      int vlmax;                                                               \
-      int vl;                                                                  \
-      std::tie(vlmax, vl) = vector_test_setup<int##_SEW_##_t>(                 \
-          VLMUL::LMUL_M##_LMUL_, avl, {test_vector_1, test_vector_2});           \
-      if (avl > vlmax) {                                                       \
-        continue;                                                              \
-      }                                                                        \
-      int##_SEW_##_t *ptr_vec_1 =                                              \
-          reinterpret_cast<int##_SEW_##_t *>(test_vector_1);                   \
-      int##_SEW_##_t *ptr_vec_2 =                                              \
-          reinterpret_cast<int##_SEW_##_t *>(test_vector_2);                   \
-      const int##_SEW_##_t test_val = TEST_VAL;                                \
-      for (int idx = 0; idx < vl; idx++) {                                     \
-        ptr_vec_1[idx] = idx;                                                  \
-      }                                                                        \
-      __asm__ volatile("vle" #_SEW_ ".v v8, (%0)" : : "r"(ptr_vec_1));         \
-      __asm__ volatile("vmax.vx v16, v8, %[RS1]" ::[RS1] "r"(test_val));       \
-      for (int idx = 0; idx < vl; idx++) {                                     \
-        ptr_vec_1[idx] =                                                       \
-            (ptr_vec_1[idx] > test_val) ? ptr_vec_1[idx] : test_val;           \
-      }                                                                        \
-      __asm__ volatile("vse" #_SEW_ ".v v16, (%0)" : : "r"(ptr_vec_2));        \
-      assert_vec_elem_eq<int##_SEW_##_t>(vlmax, test_vector_1, test_vector_2); \
-    }                                                                          \
-  }
-
-// TODO(gkielian): modify macro to permit more than one test per sew/lmul pair
-DEFINE_TEST_VMAX_VX(8, 1, INT8_MIN)
-DEFINE_TEST_VMAX_VX(8, 2, INT8_MAX)
-DEFINE_TEST_VMAX_VX(8, 4, -1)
-DEFINE_TEST_VMAX_VX(8, 8, 2)
-
-DEFINE_TEST_VMAX_VX(16, 1, INT16_MIN)
-DEFINE_TEST_VMAX_VX(16, 2, INT16_MAX)
-DEFINE_TEST_VMAX_VX(16, 4, -1)
-DEFINE_TEST_VMAX_VX(16, 8, 2)
-
-DEFINE_TEST_VMAX_VX(32, 1, INT32_MIN)
-DEFINE_TEST_VMAX_VX(32, 2, INT32_MAX)
-DEFINE_TEST_VMAX_VX(32, 4, -1)
-DEFINE_TEST_VMAX_VX(32, 8, 2)
-
-}  // namespace
-}  // namespace vmax_vx_test