diff --git a/apps/hexagon_api/CMakeLists.txt b/apps/hexagon_api/CMakeLists.txt
index 5234be3c1a15..aa971c875307 100644
--- a/apps/hexagon_api/CMakeLists.txt
+++ b/apps/hexagon_api/CMakeLists.txt
@@ -45,7 +45,7 @@ ExternalProject_Add(x86_tvm_runtime_rpc
     "-DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}"
     "-DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}"
     "-DUSE_HEXAGON_TOOLCHAIN=${USE_HEXAGON_TOOLCHAIN}"
-    "-DCMAKE_CXX_STANDARD=14"
+    "-DCMAKE_CXX_STANDARD=17"
     "-DUSE_LIBBACKTRACE=OFF"
     "-DUSE_RPC=ON"
     "-DUSE_CPP_RPC=ON"
@@ -79,7 +79,7 @@ ExternalProject_Add(android_tvm_runtime_rpc
     "-DANDROID_ABI=${ANDROID_ABI}"
     "-DUSE_HEXAGON_SDK=${USE_HEXAGON_SDK}"
     "-DUSE_HEXAGON_ARCH=${USE_HEXAGON_ARCH}"
-    "-DCMAKE_CXX_STANDARD=14"
+    "-DCMAKE_CXX_STANDARD=17"
     "-DUSE_LIBBACKTRACE=OFF"
     "-DUSE_RPC=ON"
     "-DUSE_CPP_RPC=ON"
@@ -123,6 +123,7 @@ ExternalProject_Add(hexagon_tvm_runtime_rpc
     "-DCMAKE_CXX_COMPILER=${USE_HEXAGON_TOOLCHAIN}/bin/hexagon-clang++"
     "-DUSE_HEXAGON_SDK=${USE_HEXAGON_SDK}"
     "-DUSE_HEXAGON_ARCH=${USE_HEXAGON_ARCH}"
+    "-DCMAKE_CXX_STANDARD=17"
     "-DUSE_LIBBACKTRACE=OFF"
     "-DUSE_RPC=OFF"
     "-DUSE_HEXAGON=ON"
diff --git a/apps/hexagon_launcher/cmake/android/CMakeLists.txt b/apps/hexagon_launcher/cmake/android/CMakeLists.txt
index 69334a3b690b..84ff4add284b 100644
--- a/apps/hexagon_launcher/cmake/android/CMakeLists.txt
+++ b/apps/hexagon_launcher/cmake/android/CMakeLists.txt
@@ -73,7 +73,7 @@ ExternalProject_Add(android_tvm_runtime
   CMAKE_ARGS
   "-DANDROID_ABI=${ANDROID_ABI}"
   "-DANDROID_PLATFORM=${ANDROID_PLATFORM}"
-  "-DCMAKE_CXX_STANDARD=14"
+  "-DCMAKE_CXX_STANDARD=17"
   "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
   "-DUSE_HEXAGON=ON"
   "-DUSE_GRAPH_EXECUTOR=OFF"
diff --git a/apps/hexagon_launcher/cmake/hexagon/CMakeLists.txt b/apps/hexagon_launcher/cmake/hexagon/CMakeLists.txt
index 0e7abb532fd7..fa17dcb4778b 100644
--- a/apps/hexagon_launcher/cmake/hexagon/CMakeLists.txt
+++ b/apps/hexagon_launcher/cmake/hexagon/CMakeLists.txt
@@ -82,7 +82,7 @@ ExternalProject_Add(static_hexagon_tvm_runtime
   "-DBUILD_STATIC_RUNTIME=ON"
   "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}"
   "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-  "-DCMAKE_CXX_STANDARD=14"
+  "-DCMAKE_CXX_STANDARD=17"
   "-DUSE_HEXAGON=ON"
   "-DUSE_HEXAGON_ARCH=${USE_HEXAGON_ARCH}"
   "-DUSE_HEXAGON_SDK=${USE_HEXAGON_SDK}"
diff --git a/conda/recipe/build.sh b/conda/recipe/build.sh
index bfae99f77944..0131fd65a48e 100755
--- a/conda/recipe/build.sh
+++ b/conda/recipe/build.sh
@@ -26,7 +26,7 @@ MACOS_OPT=""
 if [ "$target_platform" == "osx-64" ]; then
     # macOS 64 bits
     GPU_OPT="-DUSE_METAL=ON"
-    MACOS_OPT="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.12"
+    MACOS_OPT="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13"
 elif [ "$target_platform" == "linux-64" ]; then
     TOOLCHAIN_OPT="-DCMAKE_TOOLCHAIN_FILE=${RECIPE_DIR}/cross-linux.cmake"
 fi
diff --git a/src/relay/transforms/fold_explicit_padding.cc b/src/relay/transforms/fold_explicit_padding.cc
index 37385f80c1c9..794bcfd3d07d 100644
--- a/src/relay/transforms/fold_explicit_padding.cc
+++ b/src/relay/transforms/fold_explicit_padding.cc
@@ -22,7 +22,6 @@
  * \brief A pass for folding explicit pads into other ops.
  */
 
-#include <dmlc/optional.h>
 #include <tvm/relay/dataflow_matcher.h>
 #include <tvm/relay/expr.h>
 #include <tvm/relay/expr_functor.h>
@@ -32,6 +31,10 @@
 #include <tvm/tir/op.h>
 #include <tvm/topi/nn/pooling.h>
 
+#include <optional>
+#include <set>
+#include <string>
+
 #include "../op/tensor/transform.h"
 #include "pattern_utils.h"
 
@@ -180,10 +183,10 @@ class SimplifyExplicitPad {
     return attrs;
   }
 
-  static const Optional<Array<PrimExpr>> get_padding(const PadAttrs* param,
-                                                     std::string data_layout) {
+  static const std::optional<Array<PrimExpr>> get_padding(const PadAttrs* param,
+                                                          std::string data_layout) {
     // Gets spatial axes padding from the given PadAttrs `param`. If padding
-    // is non-zero on non-spatial axes, return NullOpt.
+    // is non-zero on non-spatial axes, return std::nullopt.
     ICHECK(param);
     ICHECK(data_layout.size() == param->pad_width.size())
         << "Data Layout and padding attributes should have the same extent";
@@ -196,7 +199,7 @@ class SimplifyExplicitPad {
       if (!image_dims.count(data_layout[i])) {
         for (size_t j = 0; j < param->pad_width[i].size(); ++j) {
           if (param->pad_width[i][j] != 0) {
-            return NullOpt;
+            return std::nullopt;
           }
         }
       }
diff --git a/src/relay/transforms/pattern_utils.h b/src/relay/transforms/pattern_utils.h
index f71d84434dbb..d05d39b733d3 100644
--- a/src/relay/transforms/pattern_utils.h
+++ b/src/relay/transforms/pattern_utils.h
@@ -27,7 +27,6 @@
 #define TVM_RELAY_TRANSFORMS_PATTERN_UTILS_H_
 
 #include <builtin_fp16.h>
-#include <dmlc/optional.h>
 #include <tvm/node/structural_equal.h>
 #include <tvm/relay/analysis.h>
 #include <tvm/relay/attrs/nn.h>
@@ -40,6 +39,7 @@
 #include <tvm/tir/data_layout.h>
 
 #include <limits>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -405,48 +405,47 @@ inline bool IsEqualScalar(const Expr& a, const Expr& b) {
  * \param i element index
  * \return Converted scalar value, or None if conversion failed
  */
-static inline dmlc::optional<long double> TryToScalar(const runtime::NDArray& array, size_t i = 0) {
+static inline std::optional<long double> TryToScalar(const runtime::NDArray& array, size_t i = 0) {
   if (array->dtype.code == kDLInt) {
     if (array->dtype.bits == 8) {
-      return dmlc::optional<long double>(reinterpret_cast<int8_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<int8_t*>(array->data)[i]);
     } else if (array->dtype.bits == 16) {
-      return dmlc::optional<long double>(reinterpret_cast<int16_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<int16_t*>(array->data)[i]);
     } else if (array->dtype.bits == 32) {
-      return dmlc::optional<long double>(reinterpret_cast<int32_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<int32_t*>(array->data)[i]);
     } else if (array->dtype.bits == 64) {
-      return dmlc::optional<long double>(reinterpret_cast<int64_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<int64_t*>(array->data)[i]);
     }
   } else if (array->dtype.code == kDLUInt) {
     if (array->dtype.bits == 1) {  // bool
-      return dmlc::optional<long double>(reinterpret_cast<uint8_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<uint8_t*>(array->data)[i]);
     } else if (array->dtype.bits == 8) {
-      return dmlc::optional<long double>(reinterpret_cast<uint8_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<uint8_t*>(array->data)[i]);
     } else if (array->dtype.bits == 16) {
-      return dmlc::optional<long double>(reinterpret_cast<uint16_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<uint16_t*>(array->data)[i]);
     } else if (array->dtype.bits == 32) {
-      return dmlc::optional<long double>(reinterpret_cast<uint32_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<uint32_t*>(array->data)[i]);
     } else if (array->dtype.bits == 64) {
-      return dmlc::optional<long double>(reinterpret_cast<uint64_t*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<uint64_t*>(array->data)[i]);
     }
   } else if (array->dtype.code == kDLFloat) {
     if (array->dtype.bits == 16) {
-      return dmlc::optional<long double>(
+      return std::optional<long double>(
           __extendXfYf2__<uint16_t, uint16_t, 10, float, uint32_t, 23>(
               reinterpret_cast<uint16_t*>(array->data)[i]));
     }
     if (array->dtype.bits == 32) {
-      return dmlc::optional<long double>(reinterpret_cast<float*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<float*>(array->data)[i]);
     } else if (array->dtype.bits == 64) {
-      return dmlc::optional<long double>(reinterpret_cast<double*>(array->data)[i]);
+      return std::optional<long double>(reinterpret_cast<double*>(array->data)[i]);
     }
   } else if (array->dtype.code == kDLBfloat) {
     if (array->dtype.bits == 16) {
-      return dmlc::optional<long double>(
-          __extendXfYf2__<uint16_t, uint16_t, 7, float, uint32_t, 23>(
-              reinterpret_cast<uint16_t*>(array->data)[i]));
+      return std::optional<long double>(__extendXfYf2__<uint16_t, uint16_t, 7, float, uint32_t, 23>(
+          reinterpret_cast<uint16_t*>(array->data)[i]));
     }
   }
-  return dmlc::optional<long double>();
+  return std::nullopt;
 }
 
 /*!
diff --git a/src/runtime/hexagon/rpc/simulator/session.cc b/src/runtime/hexagon/rpc/simulator/session.cc
index 0469ad5e6e1a..8943c0b4bfe5 100644
--- a/src/runtime/hexagon/rpc/simulator/session.cc
+++ b/src/runtime/hexagon/rpc/simulator/session.cc
@@ -18,7 +18,6 @@
  */
 
 #include <HexagonWrapper.h>
-#include <dmlc/optional.h>
 #include <tvm/runtime/packed_func.h>
 #include <tvm/runtime/registry.h>
 // POSIX includes
@@ -31,6 +30,7 @@
 #include <iterator>
 #include <map>
 #include <memory>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -55,19 +55,6 @@ using string_list = std::deque<std::string>;
 
 namespace detail {
 
-// An "Optional" class, originally a replacement for llvm::Optional, then an
-// extension of dmlc::optional to make it compatible with C++17's std::optional.
-template <typename T>
-struct Optional : public dmlc::optional<T> {
-  using dmlc::optional<T>::optional;
-  using dmlc::optional<T>::operator=;
-  Optional(const T& val) : dmlc::optional<T>(val) {}  // NOLINT(*)
-  Optional() = default;
-
-  T* operator->() { return &this->operator*(); }
-  const T* operator->() const { return &this->operator*(); }
-};
-
 // Replacement for llvm::StringSwitch.
 template <typename T>
 class StringSwitch {
@@ -94,10 +81,10 @@ class StringSwitch {
  private:
   const std::string key;
   std::map<std::string, T> map;
-  Optional<T> def_val;
+  std::optional<T> def_val;
 };
 
-using MaybeString = Optional<std::string>;
+using MaybeString = std::optional<std::string>;
 
 MaybeString front(const string_list& deq) {
   return !deq.empty() ? MaybeString(deq.front()) : MaybeString();
@@ -112,65 +99,60 @@ MaybeString pop_front(string_list& deq) {  // NOLINT(*)
 
 // Functions used when parsing the argument string.
 
-Optional<int64_t> to_int(const MaybeString& str) {
-  auto none = Optional<int64_t>();
+std::optional<int64_t> to_int(const MaybeString& str) {
   if (str.has_value()) {
     try {
       size_t pos;
       int64_t val = std::stoll(*str, &pos, 0);
-      return pos == str->size() ? Optional<int64_t>(val) : none;
+      return pos == str->size() ? std::optional<int64_t>(val) : std::nullopt;
     } catch (std::invalid_argument&) {
     }
   }
-  return none;
+  return std::nullopt;
 }
 
-Optional<uint64_t> to_uint(const MaybeString& str) {
-  auto none = Optional<uint64_t>();
+std::optional<uint64_t> to_uint(const MaybeString& str) {
   if (str.has_value()) {
     try {
       size_t pos;
       uint64_t val = std::stoull(*str, &pos, 0);
-      return pos == str->size() ? Optional<uint64_t>(val) : none;
+      return pos == str->size() ? std::optional<uint64_t>(val) : std::nullopt;
     } catch (std::invalid_argument&) {
     }
   }
-  return none;
+  return std::nullopt;
 }
 
-Optional<float> to_float(const MaybeString& str) {
-  auto none = Optional<float>();
+std::optional<float> to_float(const MaybeString& str) {
   if (str.has_value()) {
     try {
       size_t pos;
       float val = std::stof(*str, &pos);
-      return pos == str->size() ? Optional<float>(val) : none;
+      return pos == str->size() ? std::optional<float>(val) : std::nullopt;
     } catch (std::invalid_argument&) {
     }
   }
-  return none;
+  return std::nullopt;
 }
 
-Optional<bool> to_bool(const MaybeString& str) {
-  auto none = Optional<bool>();
+std::optional<bool> to_bool(const MaybeString& str) {
   if (auto num = to_int(str)) {
     if (*num == 0) return false;
     if (*num == 1) return true;
-    return none;
+    return std::nullopt;
   }
   if (str) {
     if (*str == "true" || *str == "TRUE") return true;
     if (*str == "false" || *str == "FALSE") return false;
   }
-  return none;
+  return std::nullopt;
 }
 
 template <typename T>
-using MaybeRange = Optional<std::pair<T, T>>;
+using MaybeRange = std::optional<std::pair<T, T>>;
 
-template <typename T, Optional<T> Parse(const MaybeString&)>
+template <typename T, std::optional<T> Parse(const MaybeString&)>
 MaybeRange<T> to_range(const MaybeString& str) {
-  auto none = MaybeRange<T>();
   if (str && !str->empty()) {
     auto n = str->find('-', 1);
     if (n != std::string::npos) {
@@ -181,7 +163,7 @@ MaybeRange<T> to_range(const MaybeString& str) {
       }
     }
   }
-  return none;
+  return std::nullopt;
 }
 
 }  // namespace detail
@@ -227,7 +209,7 @@ class SimulatorRPCChannel final : public RPCChannel {
   static HEX_8u_t PassVirtAddrCallback(void* handle, int threadno, HEX_8u_t RssV, HEX_8u_t RttV,
                                        HEX_8u_t RxxV, HEX_1u_t imm);
 
-  detail::Optional<HEXAPI_Cpu> GetCPU(const detail::MaybeString& cpu_str);
+  std::optional<HEXAPI_Cpu> GetCPU(const detail::MaybeString& cpu_str);
 
   // File name templates for mkstemps.
 #define SUFFIX ".cfg"
@@ -306,17 +288,17 @@ class SimulatorRPCChannel final : public RPCChannel {
   bool HandleV2PTranslation(string_list& rest);     // NOLINT(*)
   bool HandleVerbose(string_list& rest);            // NOLINT(*)
 
-  using MaybeUInt64 = detail::Optional<uint64_t>;
+  using MaybeUInt64 = std::optional<uint64_t>;
   using MaybeUIntRange = std::pair<MaybeUInt64, MaybeUInt64>;
 
   bool should_parse_next(const string_list& rest);
-  detail::Optional<HEXAPI_Interval> to_interval(const detail::MaybeString& str);
-  detail::Optional<HEXAPI_TimingMode> to_timingmode(const detail::MaybeString& str);
-  detail::Optional<HEXAPI_VerboseMode> to_verbosemode(const detail::MaybeString& str);
-  detail::Optional<HEXAPI_Nullptr> to_nullptr(const detail::MaybeString& str);
+  std::optional<HEXAPI_Interval> to_interval(const detail::MaybeString& str);
+  std::optional<HEXAPI_TimingMode> to_timingmode(const detail::MaybeString& str);
+  std::optional<HEXAPI_VerboseMode> to_verbosemode(const detail::MaybeString& str);
+  std::optional<HEXAPI_Nullptr> to_nullptr(const detail::MaybeString& str);
 
   MaybeUIntRange ahb_, axi2_;
-  detail::Optional<uint32_t> debug_port_;
+  std::optional<uint32_t> debug_port_;
 
   using OptionHandler = bool (SimulatorRPCChannel::*)(string_list&);
   static std::map<std::string, OptionHandler> opt_map_;
@@ -556,15 +538,14 @@ HEX_8u_t SimulatorRPCChannel::PassVirtAddrCallback(void* handle, int threadno, H
   return RssV;
 }
 
-detail::Optional<HEXAPI_Cpu> SimulatorRPCChannel::GetCPU(const detail::MaybeString& cpu_str) {
-  auto none = detail::Optional<HEXAPI_Cpu>();
-  if (!cpu_str) return none;
-  return detail::StringSwitch<detail::Optional<HEXAPI_Cpu>>(*cpu_str)
+std::optional<HEXAPI_Cpu> SimulatorRPCChannel::GetCPU(const detail::MaybeString& cpu_str) {
+  if (!cpu_str) return std::nullopt;
+  return detail::StringSwitch<std::optional<HEXAPI_Cpu>>(*cpu_str)
       .Case("v65", HEX_CPU_V65)
       .Case("v66", HEX_CPU_V66)
       .Case("v68", HEX_CPU_V68)
       .Case("v69", HEX_CPU_V69)
-      .Default(none);
+      .Default(std::nullopt);
 }
 
 SimulatorRPCChannel::SimulatorRPCChannel(int stack_size, std::string args) {
@@ -1265,9 +1246,8 @@ bool SimulatorRPCChannel::should_parse_next(const string_list& rest) {
   return false;
 }
 
-detail::Optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail::MaybeString& str) {
-  auto none = detail::Optional<HEXAPI_Interval>();
-  if (!str) return none;
+std::optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail::MaybeString& str) {
+  if (!str) return std::nullopt;
 
   if (auto val = detail::to_int(*str)) {
     switch (*val) {
@@ -1280,19 +1260,18 @@ detail::Optional<HEXAPI_Interval> SimulatorRPCChannel::to_interval(const detail:
     }
   }
 
-  return detail::StringSwitch<detail::Optional<HEXAPI_Interval>>(*str)
+  return detail::StringSwitch<std::optional<HEXAPI_Interval>>(*str)
       .Case("MILLISEC", HEX_MILLISEC)
       .Case("MICROSEC", HEX_MICROSEC)
       .Case("NANOSEC", HEX_NANOSEC)
       .Case("PICOSEC", HEX_PICOSEC)
       .Case("PCYCLE", HEX_PCYCLE)
-      .Default(none);
+      .Default(std::nullopt);
 }
 
-detail::Optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
+std::optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
     const detail::MaybeString& str) {
-  auto none = detail::Optional<HEXAPI_TimingMode>();
-  if (!str) return none;
+  if (!str) return std::nullopt;
 
   if (auto val = detail::to_int(*str)) {
     switch (*val) {
@@ -1304,18 +1283,17 @@ detail::Optional<HEXAPI_TimingMode> SimulatorRPCChannel::to_timingmode(
     }
   }
 
-  return detail::StringSwitch<detail::Optional<HEXAPI_TimingMode>>(*str)
+  return detail::StringSwitch<std::optional<HEXAPI_TimingMode>>(*str)
       .Case("NOTIMING", HEX_NOTIMING)
       .Case("TIMING_NODBC", HEX_TIMING_NODBC)
       .Case("TIMING", HEX_TIMING)
       .Case("TIMING_COHERENCY", HEX_TIMING_COHERENCY)
-      .Default(none);
+      .Default(std::nullopt);
 }
 
-detail::Optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
+std::optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
     const detail::MaybeString& str) {
-  auto none = detail::Optional<HEXAPI_VerboseMode>();
-  if (!str) return none;
+  if (!str) return std::nullopt;
 
   if (auto val = detail::to_int(*str)) {
     switch (*val) {
@@ -1328,18 +1306,17 @@ detail::Optional<HEXAPI_VerboseMode> SimulatorRPCChannel::to_verbosemode(
     }
   }
 
-  return detail::StringSwitch<detail::Optional<HEXAPI_VerboseMode>>(*str)
+  return detail::StringSwitch<std::optional<HEXAPI_VerboseMode>>(*str)
       .Case("SILENT", HEX_SILENT)
       .Case("QUIET", HEX_QUIET)
       .Case("NORMAL", HEX_NORMAL)
       .Case("VERBOSE", HEX_VERBOSE)
       .Case("REALLY_VERBOSE", HEX_REALLY_VERBOSE)
-      .Default(none);
+      .Default(std::nullopt);
 }
 
-detail::Optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::MaybeString& str) {
-  auto none = detail::Optional<HEXAPI_Nullptr>();
-  if (!str) return none;
+std::optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::MaybeString& str) {
+  if (!str) return std::nullopt;
 
   if (auto val = detail::to_int(*str)) {
     switch (*val) {
@@ -1351,12 +1328,12 @@ detail::Optional<HEXAPI_Nullptr> SimulatorRPCChannel::to_nullptr(const detail::M
     }
   }
 
-  return detail::StringSwitch<detail::Optional<HEXAPI_Nullptr>>(*str)
+  return detail::StringSwitch<std::optional<HEXAPI_Nullptr>>(*str)
       .Case("IGNORE", HEX_NULLPTR_IGNORE)
       .Case("WARN", HEX_NULLPTR_WARN)
       .Case("FATAL", HEX_NULLPTR_FATAL)
       .Case("PCZERO", HEX_NULLPTR_PCZERO)
-      .Default(none);
+      .Default(std::nullopt);
 }
 
 TVM_REGISTER_GLOBAL("tvm.contrib.hexagon.create_hexagon_session")
diff --git a/src/runtime/vm/profiler/vm.cc b/src/runtime/vm/profiler/vm.cc
index 0ace910b5c53..db8a3f5dc2c4 100644
--- a/src/runtime/vm/profiler/vm.cc
+++ b/src/runtime/vm/profiler/vm.cc
@@ -73,7 +73,7 @@ PackedFunc VirtualMachineDebug::GetFunction(const std::string& name,
           invoke(arg_name);
           prof_.operator*().Stop();
           auto report = prof_.operator*().Report();
-          prof_ = dmlc::optional<profiling::Profiler>();  // releases hardware counters
+          prof_ = std::nullopt;  // releases hardware counters
           return report;
         });
   } else if (name == "profile_rpc") {
diff --git a/src/runtime/vm/profiler/vm.h b/src/runtime/vm/profiler/vm.h
index 0c9e94c0ddd6..f0374c75a767 100644
--- a/src/runtime/vm/profiler/vm.h
+++ b/src/runtime/vm/profiler/vm.h
@@ -25,11 +25,11 @@
 #ifndef TVM_RUNTIME_VM_PROFILER_VM_H_
 #define TVM_RUNTIME_VM_PROFILER_VM_H_
 
-#include <dmlc/optional.h>
 #include <tvm/runtime/profiling.h>
 #include <tvm/runtime/vm/vm.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -55,7 +55,7 @@ class VirtualMachineDebug : public VirtualMachine {
   void OpStopHook() final;
 
   std::unordered_map<Index, std::string> packed_index_map_;
-  dmlc::optional<profiling::Profiler> prof_;
+  std::optional<profiling::Profiler> prof_;
 };
 
 }  // namespace vm
diff --git a/src/te/autodiff/ad_simplify.cc b/src/te/autodiff/ad_simplify.cc
index 240adf14b31d..28f57c77da70 100644
--- a/src/te/autodiff/ad_simplify.cc
+++ b/src/te/autodiff/ad_simplify.cc
@@ -44,7 +44,6 @@
  * Due to TVM's restriction, we also lift the reduction to the top of the compute stage.
  *
  */
-#include <dmlc/optional.h>
 #include <tvm/arith/analyzer.h>
 #include <tvm/arith/int_solver.h>
 #include <tvm/runtime/registry.h>
@@ -54,6 +53,7 @@
 
 #include <iterator>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "ad_utils.h"
@@ -629,9 +629,9 @@ class EliminateDivModMutator : public ExprMutator {
   }
 
  private:
-  dmlc::optional<std::pair<Var, Var>> AddNewVarPair(const PrimExpr& e, const PrimExpr& mut,
-                                                    int64_t val, DivMode mode) {
-    using tresult = dmlc::optional<std::pair<Var, Var>>;
+  std::optional<std::pair<Var, Var>> AddNewVarPair(const PrimExpr& e, const PrimExpr& mut,
+                                                   int64_t val, DivMode mode) {
+    using tresult = std::optional<std::pair<Var, Var>>;
 
     // Try to find the variables using the mutated expressions
     if (!e.same_as(mut)) {
diff --git a/src/tir/transforms/common_subexpr_elim_tools.h b/src/tir/transforms/common_subexpr_elim_tools.h
index fcd29fddc0a1..0871fd009149 100644
--- a/src/tir/transforms/common_subexpr_elim_tools.h
+++ b/src/tir/transforms/common_subexpr_elim_tools.h
@@ -33,12 +33,11 @@
 #include <tvm/tir/stmt.h>
 #include <tvm/tir/stmt_functor.h>  // For the class StmtExprVisitor
 
+#include <optional>
 #include <unordered_map>  // For the hashtable datatype
 #include <utility>        // For pairs datatype
 #include <vector>
 
-#include "../../../3rdparty/dmlc-core/include/dmlc/optional.h"
-
 namespace tvm {
 namespace tir {
 
@@ -177,7 +176,7 @@ class UsesVarName : public StmtExprVisitor {
  */
 void PrintComputationTable(const ComputationTable& table);
 
-using MaybeValue = dmlc::optional<PrimExpr>;
+using MaybeValue = std::optional<PrimExpr>;
 
 bool EqualTerms(const PrimExpr& a, const PrimExpr& b);
 // Used for deciding the (decidable) equivalence relation