diff --git a/softrvv/include/softrvv.h b/softrvv/include/softrvv.h
index 5595634..d82e7a0 100644
--- a/softrvv/include/softrvv.h
+++ b/softrvv/include/softrvv.h
@@ -10,20 +10,21 @@
 #include "softrvv_vdiv.h"
 #include "softrvv_vmax.h"
 #include "softrvv_vmin.h"
-#include "softrvv_vmul_vmulh.h"
 #include "softrvv_vmseq.h"
-#include "softrvv_vmsgt.h"
 #include "softrvv_vmsge.h"
+#include "softrvv_vmsgt.h"
 #include "softrvv_vmsle.h"
 #include "softrvv_vmslt.h"
 #include "softrvv_vmsne.h"
+#include "softrvv_vmul_vmulh.h"
+#include "softrvv_vmv_s_x.h"
 #include "softrvv_vnsra.h"
 #include "softrvv_vnsrl.h"
 #include "softrvv_vor.h"
 #include "softrvv_vrem.h"
 #include "softrvv_vsext_vzext.h"
-#include "softrvv_vsra.h"
 #include "softrvv_vsll.h"
+#include "softrvv_vsra.h"
 #include "softrvv_vsrl.h"
 #include "softrvv_vsub.h"
 #include "softrvv_vwadd.h"
diff --git a/softrvv/include/softrvv_vmv_s_x.h b/softrvv/include/softrvv_vmv_s_x.h
new file mode 100644
index 0000000..5e249a0
--- /dev/null
+++ b/softrvv/include/softrvv_vmv_s_x.h
@@ -0,0 +1,15 @@
+#ifndef SOFTRVV_VMV_S_X_H
+#define SOFTRVV_VMV_S_X_H
+
+#include <stddef.h>
+
+namespace softrvv {
+
+template <typename T1, typename T2>
+void vmv_s_x(T1 *vd, const T2 *rs1) {
+  vd[0] = static_cast<T1>(*rs1);
+}
+
+}  // namespace softrvv
+
+#endif  // SOFTRVV_VMV_S_X_H
diff --git a/softrvv/tests/CMakeLists.txt b/softrvv/tests/CMakeLists.txt
index fd87980..62cbc9a 100644
--- a/softrvv/tests/CMakeLists.txt
+++ b/softrvv/tests/CMakeLists.txt
@@ -292,3 +292,15 @@
   LINKOPTS
    -Xlinker --defsym=__itcm_length__=128K
 )
+
+vec_cc_test(
+  NAME
+    softrvv_vmv_s_x
+  SRCS
+    softrvv_vmv_s_x_test.cpp
+  DEPS
+    softrvv
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+)
+
diff --git a/softrvv/tests/softrvv_vmv_s_x_test.cpp b/softrvv/tests/softrvv_vmv_s_x_test.cpp
new file mode 100644
index 0000000..fd10f46
--- /dev/null
+++ b/softrvv/tests/softrvv_vmv_s_x_test.cpp
@@ -0,0 +1,55 @@
+#include <limits.h>
+#include <riscv_vector.h>
+#include <springbok.h>
+#include <stdio.h>
+
+#include "pw_unit_test/framework.h"
+#include "softrvv.h"
+
+namespace softrvv_vand_test {
+namespace {
+
+int8_t dest_e8[] = {-5, 3, 0};
+int16_t dest_e16[] = {-5, 3, 0};
+int32_t dest_e32[] = {-5, 3, 0};
+
+// register value will truncate and replace vd[0]
+int32_t rs1[] = {INT32_MIN, -1, 1, INT32_MAX};
+
+const uint32_t kAVL = sizeof(dest_e8) / sizeof(dest_e8[0]);
+const int32_t num_vx_tests = sizeof(rs1) / sizeof(rs1[0]);
+
+int8_t ref_vx_e8[num_vx_tests][kAVL] = {{static_cast<int8_t>(INT32_MIN), 3, 0},
+                                        {-1, 3, 0},
+                                        {1, 3, 0},
+                                        {static_cast<int8_t>(INT32_MAX), 3, 0}};
+
+int16_t ref_vx_e16[num_vx_tests][kAVL] = {
+    {static_cast<int16_t>(INT32_MIN), 3, 0},
+    {-1, 3, 0},
+    {1, 3, 0},
+    {static_cast<int16_t>(INT32_MAX), 3, 0}};
+
+int32_t ref_vx_e32[num_vx_tests][kAVL] = {
+    {INT32_MIN, 3, 0}, {-1, 3, 0}, {1, 3, 0}, {INT32_MAX, 3, 0}};
+
+class SoftRvvVmvsxTest : public ::testing::Test {
+ protected:
+  void SetUp() override {}
+};
+
+TEST_F(SoftRvvVmvsxTest, S_X) {
+  for (int32_t i = 0; i < num_vx_tests; i++) {
+    softrvv::vmv_s_x<int8_t, int32_t>(dest_e8, &rs1[i]);
+    ASSERT_EQ(memcmp(dest_e8, &ref_vx_e8[i], sizeof(dest_e8)), 0);
+
+    softrvv::vmv_s_x<int16_t, int32_t>(dest_e16, &rs1[i]);
+    ASSERT_EQ(memcmp(dest_e16, &ref_vx_e16[i], sizeof(dest_e16)), 0);
+
+    softrvv::vmv_s_x<int32_t, int32_t>(dest_e32, &rs1[i]);
+    ASSERT_EQ(memcmp(dest_e32, &ref_vx_e32[i], sizeof(dest_e32)), 0);
+  }
+}
+
+}  // namespace
+}  // namespace softrvv_vand_test
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 58a22df..fc3db8d 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -387,6 +387,17 @@
 
 vec_cc_test(
   NAME
+    vmv_s_x_test
+  SRCS
+    vmv_s_x_test.cpp
+  LINKOPTS
+   -Xlinker --defsym=__itcm_length__=128K
+  TIMEOUT
+    40
+)
+
+vec_cc_test(
+  NAME
     vlnr_vsnr_test
   SRCS
     vlnr_vsnr_test.cpp
diff --git a/tests/vmv_s_x_test.cpp b/tests/vmv_s_x_test.cpp
new file mode 100644
index 0000000..f7993cc
--- /dev/null
+++ b/tests/vmv_s_x_test.cpp
@@ -0,0 +1,123 @@
+#include <limits.h>
+#include <riscv_vector.h>
+#include <springbok.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <bit>
+#include <tuple>
+#include <type_traits>
+
+#include "pw_unit_test/framework.h"
+#include "test_v_helpers.h"
+
+namespace vmv_s_x_test {
+namespace {
+
+using namespace test_v_helpers;
+
+uint8_t test_vector_1[MAXVL_BYTES];
+uint8_t reference_vector_1[MAXVL_BYTES];
+
+class VmvsxTest : public ::testing::Test {
+ protected:
+  void SetUp() override { zero_vector_registers(); }
+  void TearDown() override { zero_vector_registers(); }
+};
+
+template <typename T>
+void vmv_s_x_test(const int32_t test_value) {
+  for (int lmul = LMUL_M1; lmul <= LMUL_M8; lmul++) {
+    // TODO(gkielian): increase upper bound to LMUL_MF2 after support is added
+    // TODO(gkielian): skip lmul==4 (unused) on adding fractional lmul to range
+
+    for (int32_t i = 0; i < AVL_COUNT; i++) {
+      int32_t avl = AVLS[i];
+      int32_t vlmax;
+      int32_t vl;
+
+      // reset vector elements to zero and perform appropriate vsetvl
+      std::tie(vlmax, vl) = vector_test_setup<T>(
+          static_cast<VLMUL>(lmul), avl, {test_vector_1, reference_vector_1});
+      if (avl > vlmax) {
+        continue;
+      }
+
+      // recast test and ref vector to appropriate sew
+      T *test_ptr_vec = reinterpret_cast<T *>(test_vector_1);
+      T *ref_ptr_vec = reinterpret_cast<T *>(reference_vector_1);
+
+      // populate test and ref vectors
+      fill_random_vector<T>(ref_ptr_vec, avl);
+
+      // load test_value to scalar register
+      __asm__ volatile("lw x5, (%0)" : : "r"(&test_value));
+
+      switch (sizeof(T)) {
+        case sizeof(int8_t):
+          __asm__ volatile("vle8.v v8, (%0)" : : "r"(ref_ptr_vec));
+          break;
+        case sizeof(int16_t):
+          __asm__ volatile("vle16.v v8, (%0)" : : "r"(ref_ptr_vec));
+          break;
+        case sizeof(int32_t):
+          __asm__ volatile("vle32.v v8, (%0)" : : "r"(ref_ptr_vec));
+          break;
+        default:
+          EXPECT_TRUE(false);
+          break;
+      }
+
+      // load value of x5 into v8[0], truncating x5 to fit into the current SEW
+      __asm__ volatile("vmv.s.x v8, x5");
+
+      switch (sizeof(T)) {
+        case sizeof(int8_t):
+          __asm__ volatile("vse8.v v8, (%0)" : : "r"(test_ptr_vec));
+          break;
+        case sizeof(int16_t):
+          __asm__ volatile("vse16.v v8, (%0)" : : "r"(test_ptr_vec));
+          break;
+        case sizeof(int32_t):
+          __asm__ volatile("vse32.v v8, (%0)" : : "r"(test_ptr_vec));
+          break;
+        default:
+          EXPECT_TRUE(false);
+          break;
+      }
+
+      // perform operations on reference vector
+      ref_ptr_vec[0] = static_cast<T>(test_value);
+
+      assert_vec_elem_eq<T>(vlmax, test_ptr_vec, ref_ptr_vec);
+    }
+  }
+}
+
+TEST_F(VmvsxTest, vmv_s_x_test_e8) {
+  vmv_s_x_test<int8_t>(INT32_MIN);
+  vmv_s_x_test<int8_t>(INT32_MAX);
+  vmv_s_x_test<int8_t>(INT8_MIN);
+  vmv_s_x_test<int8_t>(INT8_MAX);
+  vmv_s_x_test<int8_t>(0);
+}
+
+TEST_F(VmvsxTest, vmv_s_x_test_e16) {
+  vmv_s_x_test<int16_t>(INT32_MIN);
+  vmv_s_x_test<int16_t>(INT32_MAX);
+  vmv_s_x_test<int16_t>(INT8_MIN);
+  vmv_s_x_test<int16_t>(INT8_MAX);
+  vmv_s_x_test<int16_t>(0);
+}
+
+TEST_F(VmvsxTest, vmv_s_x_test_e32) {
+  vmv_s_x_test<int32_t>(INT32_MIN);
+  vmv_s_x_test<int32_t>(INT32_MAX);
+  vmv_s_x_test<int32_t>(INT8_MIN);
+  vmv_s_x_test<int32_t>(INT8_MAX);
+  vmv_s_x_test<int32_t>(0);
+}
+
+}  // namespace
+}  // namespace vmv_s_x_test
+