diff --git a/include/guidance/intersection_handler.hpp b/include/guidance/intersection_handler.hpp
index b54d82230..aeba71755 100644
--- a/include/guidance/intersection_handler.hpp
+++ b/include/guidance/intersection_handler.hpp
@@ -17,8 +17,7 @@
 #include <cstddef>
 #include <utility>
 #include <vector>
-
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace osrm::guidance
 {
@@ -129,7 +128,7 @@ class IntersectionHandler
     //     ^ via
     //
     // For this scenario returns intersection at `b` and `b`.
-    boost::optional<IntersectionHandler::IntersectionViewAndNode>
+    std::optional<IntersectionHandler::IntersectionViewAndNode>
     getNextIntersection(const NodeID at, const EdgeID via) const;
 
     bool isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const;
diff --git a/include/guidance/sliproad_handler.hpp b/include/guidance/sliproad_handler.hpp
index a75f70a52..e2f711a1b 100644
--- a/include/guidance/sliproad_handler.hpp
+++ b/include/guidance/sliproad_handler.hpp
@@ -10,8 +10,7 @@
 #include "util/node_based_graph.hpp"
 
 #include <vector>
-
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace osrm::guidance
 {
@@ -43,7 +42,7 @@ class SliproadHandler final : public IntersectionHandler
                             Intersection intersection) const override final;
 
   private:
-    boost::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
+    std::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
                                                               const Intersection &intersection,
                                                               const NodeID at) const;
 
diff --git a/include/guidance/turn_handler.hpp b/include/guidance/turn_handler.hpp
index d3e25c79a..7f5167501 100644
--- a/include/guidance/turn_handler.hpp
+++ b/include/guidance/turn_handler.hpp
@@ -11,8 +11,7 @@
 #include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"
 
-#include <boost/optional.hpp>
-
+#include <optional>
 #include <cstddef>
 #include <utility>
 #include <vector>
@@ -72,7 +71,7 @@ class TurnHandler final : public IntersectionHandler
 
     bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;
 
-    boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
+    std::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
 
     bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
 
@@ -96,7 +95,7 @@ class TurnHandler final : public IntersectionHandler
     handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
 
     // Classification
-    boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
+    std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
 
     OSRM_ATTR_WARN_UNUSED
     Intersection assignLeftTurns(const EdgeID via_edge,
diff --git a/include/util/coordinate_calculation.hpp b/include/util/coordinate_calculation.hpp
index f41e5d7a0..9dfd0b1f9 100644
--- a/include/util/coordinate_calculation.hpp
+++ b/include/util/coordinate_calculation.hpp
@@ -4,8 +4,8 @@
 #include "util/coordinate.hpp"
 
 #include <boost/math/constants/constants.hpp>
-#include <boost/optional.hpp>
 
+#include <optional>
 #include <algorithm>
 #include <cmath>
 #include <numeric>
@@ -102,7 +102,7 @@ double bearing(const Coordinate first_coordinate, const Coordinate second_coordi
 double computeAngle(const Coordinate first, const Coordinate second, const Coordinate third);
 
 // find the center of a circle through three coordinates
-boost::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
+std::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
                                          const Coordinate second_coordinate,
                                          const Coordinate third_coordinate);
 
diff --git a/include/util/geojson_debug_policies.hpp b/include/util/geojson_debug_policies.hpp
index 3a209db0a..05dd10af6 100644
--- a/include/util/geojson_debug_policies.hpp
+++ b/include/util/geojson_debug_policies.hpp
@@ -2,6 +2,7 @@
 #define OSRM_GEOJSON_DEBUG_POLICIES
 
 #include <vector>
+#include <optional>
 
 #include "extractor/query_node.hpp"
 #include "util/coordinate.hpp"
@@ -9,8 +10,6 @@
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
 
-#include <boost/optional.hpp>
-
 namespace osrm::util
 {
 
@@ -20,7 +19,7 @@ struct NodeIdVectorToLineString
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 
     const std::vector<util::Coordinate> &node_coordinates;
 };
@@ -29,7 +28,7 @@ struct CoordinateVectorToLineString
 {
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 };
 
 struct NodeIdVectorToMultiPoint
@@ -38,7 +37,7 @@ struct NodeIdVectorToMultiPoint
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 
     const std::vector<util::Coordinate> &node_coordinates;
 };
@@ -47,7 +46,7 @@ struct CoordinateVectorToMultiPoint
 {
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
-                                  const boost::optional<json::Object> &properties = {}) const;
+                                  const std::optional<json::Object> &properties = {}) const;
 };
 
 } // namespace osrm::util
diff --git a/include/util/geojson_debug_policy_toolkit.hpp b/include/util/geojson_debug_policy_toolkit.hpp
index 62c1019ef..a73655fc2 100644
--- a/include/util/geojson_debug_policy_toolkit.hpp
+++ b/include/util/geojson_debug_policy_toolkit.hpp
@@ -5,11 +5,10 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
 
+#include <optional>
 #include <algorithm>
 #include <iterator>
 
-#include <boost/optional.hpp>
-
 namespace osrm::util
 {
 
@@ -84,7 +83,7 @@ struct NodeIdToCoordinate
 
 inline util::json::Object makeFeature(std::string type,
                                       util::json::Array coordinates,
-                                      const boost::optional<util::json::Object> &properties = {})
+                                      const std::optional<util::json::Object> &properties = {})
 {
     util::json::Object result;
     result.values["type"] = "Feature";
diff --git a/include/util/timezones.hpp b/include/util/timezones.hpp
index ff6b0bc98..63ce66394 100644
--- a/include/util/timezones.hpp
+++ b/include/util/timezones.hpp
@@ -6,10 +6,10 @@
 #include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/index/rtree.hpp>
-#include <boost/optional.hpp>
 
 #include <rapidjson/document.h>
 
+#include <optional>
 #include <chrono>
 
 namespace osrm::updater
@@ -34,7 +34,7 @@ class Timezoner
     Timezoner(const char geojson[], std::time_t utc_time_now);
     Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
 
-    boost::optional<struct tm> operator()(const point_t &point) const;
+    std::optional<struct tm> operator()(const point_t &point) const;
 
   private:
     void LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t utc_time);
diff --git a/src/guidance/intersection_handler.cpp b/src/guidance/intersection_handler.cpp
index 5fe6bc21a..da68dca30 100644
--- a/src/guidance/intersection_handler.cpp
+++ b/src/guidance/intersection_handler.cpp
@@ -427,7 +427,7 @@ void IntersectionHandler::assignTrivialTurns(const EdgeID via_eid,
         }
 }
 
-boost::optional<IntersectionHandler::IntersectionViewAndNode>
+std::optional<IntersectionHandler::IntersectionViewAndNode>
 IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) const
 {
     // We use the intersection generator to jump over traffic signals, barriers. The intersection
@@ -450,7 +450,7 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
     if (intersection_parameters.node == SPECIAL_NODEID ||
         intersection_parameters.edge == SPECIAL_EDGEID)
     {
-        return boost::none;
+        return {};
     }
 
     auto intersection = extractor::intersection::getConnectedRoads<false>(node_based_graph,
@@ -465,10 +465,10 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
 
     if (intersection.size() <= 2 || intersection.isTrafficSignalOrBarrier())
     {
-        return boost::none;
+        return {};
     }
 
-    return boost::make_optional(
+    return std::make_optional(
         IntersectionViewAndNode{std::move(intersection), intersection_node});
 }
 
diff --git a/src/guidance/sliproad_handler.cpp b/src/guidance/sliproad_handler.cpp
index 5339ed6c6..8e28f45de 100644
--- a/src/guidance/sliproad_handler.cpp
+++ b/src/guidance/sliproad_handler.cpp
@@ -634,7 +634,7 @@ Intersection SliproadHandler::operator()(const NodeID /*nid*/,
 
 // Implementation details
 
-boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
+std::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
     const EdgeID from, const Intersection &intersection, const NodeID at) const
 {
     BOOST_ASSERT(from != SPECIAL_EDGEID);
@@ -645,14 +645,14 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
 
     if (index != 0)
     {
-        return boost::make_optional(index);
+        return std::make_optional(index);
     }
 
     // Otherwise check if the road is forking into two and one of them is a Sliproad;
     // then the non-Sliproad is the obvious one.
     if (intersection.size() != 3)
     {
-        return boost::none;
+        return {};
     }
 
     const auto forking = intersection[1].instruction.type == TurnType::Fork &&
@@ -660,7 +660,7 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
 
     if (!forking)
     {
-        return boost::none;
+        return {};
     }
 
     const auto first = getNextIntersection(at, intersection.getRightmostRoad().eid);
@@ -668,27 +668,27 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
 
     if (!first || !second)
     {
-        return boost::none;
+        return {};
     }
 
     if (first->intersection.isDeadEnd() || second->intersection.isDeadEnd())
     {
-        return boost::none;
+      	return {};
     }
 
     // In case of loops at the end of the road, we will arrive back at the intersection
     // itself. If that is the case, the road is obviously not a sliproad.
     if (canBeTargetOfSliproad(first->intersection) && at != second->node)
     {
-        return boost::make_optional(std::size_t{2});
+        return std::make_optional(std::size_t{2});
     }
 
     if (canBeTargetOfSliproad(second->intersection) && at != first->node)
     {
-        return boost::make_optional(std::size_t{1});
+        return std::make_optional(std::size_t{1});
     }
 
-    return boost::none;
+    return {};
 }
 
 bool SliproadHandler::nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const
diff --git a/src/guidance/turn_handler.cpp b/src/guidance/turn_handler.cpp
index ec77b6356..bbb99dd88 100644
--- a/src/guidance/turn_handler.cpp
+++ b/src/guidance/turn_handler.cpp
@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <limits>
 #include <utility>
+#include <optional>
 
 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
 
 using osrm::util::angularDeviation;
 
@@ -590,7 +590,7 @@ Intersection TurnHandler::assignRightTurns(const EdgeID via_edge,
 }
 
 // finds a fork candidate by just looking at the geometry and angle of an intersection
-boost::optional<TurnHandler::Fork>
+std::optional<TurnHandler::Fork>
 TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
 {
     if (intersection.size() >= 3)
@@ -647,7 +647,7 @@ TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
             }
         }
     }
-    return boost::none;
+    return {};
 }
 
 // check if the fork candidates (all roads between left and right) and the
@@ -695,7 +695,7 @@ bool TurnHandler::isCompatibleByRoadClass(const Intersection &intersection, cons
 
 // Checks whether a three-way-intersection coming from `via_edge` is a fork
 // with `intersection` as described as in #IntersectionExplanation@intersection_handler.hpp
-boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
+std::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
                                                          Intersection &intersection) const
 {
     auto fork = findForkCandidatesByGeometry(intersection);
@@ -740,7 +740,7 @@ boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
         }
     }
 
-    return boost::none;
+ 	return {};
 }
 
 void TurnHandler::handleDistinctConflict(const EdgeID via_edge,
diff --git a/src/util/coordinate_calculation.cpp b/src/util/coordinate_calculation.cpp
index 20f54bc82..fc0374ec6 100644
--- a/src/util/coordinate_calculation.cpp
+++ b/src/util/coordinate_calculation.cpp
@@ -6,6 +6,7 @@
 
 #include <boost/assert.hpp>
 
+#include <optional>
 #include <algorithm>
 #include <iterator>
 #include <limits>
@@ -173,14 +174,14 @@ double computeAngle(const Coordinate first, const Coordinate second, const Coord
     return angle;
 }
 
-boost::optional<Coordinate>
+std::optional<Coordinate>
 circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
 {
     // free after http://paulbourke.net/geometry/circlesphere/
     // require three distinct points
     if (C1 == C2 || C2 == C3 || C1 == C3)
-    {
-        return boost::none;
+  	{
+        return {};
     }
 
     // define line through c1, c2 and c2,c3
@@ -195,7 +196,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
         (std::abs(C2C1_lat) < std::numeric_limits<double>::epsilon() &&
          std::abs(C3C2_lat) < std::numeric_limits<double>::epsilon()))
     {
-        return boost::none;
+        return {};
     }
     else if (std::abs(C2C1_lon) < std::numeric_limits<double>::epsilon())
     {
@@ -233,7 +234,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
 
         // can this ever happen?
         if (std::abs(C2C1_slope - C3C2_slope) < std::numeric_limits<double>::epsilon())
-            return boost::none;
+            return {};
 
         const double C1_y = static_cast<double>(toFloating(C1.lat));
         const double C1_x = static_cast<double>(toFloating(C1.lon));
@@ -247,7 +248,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
                            (2 * (C3C2_slope - C2C1_slope));
         const double lat = (0.5 * (C1_x + C2_x) - lon) / C2C1_slope + 0.5 * (C1_y + C2_y);
         if (lon < -180.0 || lon > 180.0 || lat < -90.0 || lat > 90.0)
-            return boost::none;
+        	return {};
         else
             return Coordinate(FloatLongitude{lon}, FloatLatitude{lat});
     }
diff --git a/src/util/geojson_debug_policies.cpp b/src/util/geojson_debug_policies.cpp
index afdba87ab..9fd2ad60d 100644
--- a/src/util/geojson_debug_policies.cpp
+++ b/src/util/geojson_debug_policies.cpp
@@ -17,7 +17,7 @@ NodeIdVectorToLineString::NodeIdVectorToLineString(
 // converts a vector of node ids into a linestring geojson feature
 util::json::Object
 NodeIdVectorToLineString::operator()(const std::vector<NodeID> &node_ids,
-                                     const boost::optional<json::Object> &properties) const
+                                     const std::optional<json::Object> &properties) const
 {
     util::json::Array coordinates;
     std::transform(node_ids.begin(),
@@ -37,7 +37,7 @@ NodeIdVectorToMultiPoint::NodeIdVectorToMultiPoint(
 
 util::json::Object
 NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
-                                     const boost::optional<json::Object> &properties) const
+                                     const std::optional<json::Object> &properties) const
 {
     util::json::Array coordinates;
     std::transform(node_ids.begin(),
@@ -51,7 +51,7 @@ NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
 //----------------------------------------------------------------
 util::json::Object
 CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &input_coordinates,
-                                         const boost::optional<json::Object> &properties) const
+                                         const std::optional<json::Object> &properties) const
 {
     auto coordinates = makeJsonArray(input_coordinates);
     return makeFeature("MultiPoint", std::move(coordinates), properties);
@@ -60,7 +60,7 @@ CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &in
 //----------------------------------------------------------------
 util::json::Object
 CoordinateVectorToLineString::operator()(const std::vector<util::Coordinate> &input_coordinates,
-                                         const boost::optional<json::Object> &properties) const
+                                         const std::optional<json::Object> &properties) const
 {
     auto coordinates = makeJsonArray(input_coordinates);
     return makeFeature("LineString", std::move(coordinates), properties);
diff --git a/src/util/timezones.cpp b/src/util/timezones.cpp
index 3f478eff3..fe5e1b27c 100644
--- a/src/util/timezones.cpp
+++ b/src/util/timezones.cpp
@@ -5,12 +5,12 @@
 
 #include <boost/filesystem/fstream.hpp>
 #include <boost/filesystem/path.hpp>
-#include <boost/optional.hpp>
 
 #include <rapidjson/document.h>
 #include <rapidjson/error/en.h>
 #include <rapidjson/istreamwrapper.h>
 
+#include <optional>
 #include <fstream>
 #include <regex>
 #include <string>
@@ -158,7 +158,7 @@ void Timezoner::LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t ut
     rtree = rtree_t(polygons);
 }
 
-boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
+std::optional<struct tm> Timezoner::operator()(const point_t &point) const
 {
     std::vector<rtree_t::value_type> result;
     rtree.query(boost::geometry::index::intersects(point), std::back_inserter(result));
@@ -168,6 +168,6 @@ boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
         if (boost::geometry::within(point, local_times[index].first))
             return local_times[index].second;
     }
-    return boost::none;
+    return {};
 }
 } // namespace osrm::updater