diff --git a/examples/ISAM2Example_SmartFactor.cpp b/examples/ISAM2Example_SmartFactor.cpp
index 7dbd8323b..a874efc9a 100644
--- a/examples/ISAM2Example_SmartFactor.cpp
+++ b/examples/ISAM2Example_SmartFactor.cpp
@@ -105,7 +105,7 @@ int main(int argc, char* argv[]) {
     Values currentEstimate = isam.calculateEstimate();
     currentEstimate.print("Current estimate: ");
 
-    boost::optional<Point3> pointEstimate = smartFactor->point(currentEstimate);
+    auto pointEstimate = smartFactor->point(currentEstimate);
     if (pointEstimate) {
       cout << *pointEstimate << endl;
     } else {
diff --git a/examples/SFMExample_SmartFactor.cpp b/examples/SFMExample_SmartFactor.cpp
index 86e6b8ae9..c3400a0f9 100644
--- a/examples/SFMExample_SmartFactor.cpp
+++ b/examples/SFMExample_SmartFactor.cpp
@@ -114,10 +114,10 @@ int main(int argc, char* argv[]) {
     // The graph stores Factor shared_ptrs, so we cast back to a SmartFactor first
     SmartFactor::shared_ptr smart = boost::dynamic_pointer_cast<SmartFactor>(graph[j]);
     if (smart) {
-      // The output of point() is in boost::optional<Point3>, as sometimes
+      // The output of point() is in std::optional<Point3>, as sometimes
       // the triangulation operation inside smart factor will encounter degeneracy.
-      boost::optional<Point3> point = smart->point(result);
-      if (point) // ignore if boost::optional return nullptr
+      auto point = smart->point(result);
+      if (point) // ignore if std::optional return nullptr
         landmark_result.insert(j, *point);
     }
   }
diff --git a/examples/SFMExample_SmartFactorPCG.cpp b/examples/SFMExample_SmartFactorPCG.cpp
index 3f553efc6..2f03a4ef0 100644
--- a/examples/SFMExample_SmartFactorPCG.cpp
+++ b/examples/SFMExample_SmartFactorPCG.cpp
@@ -110,8 +110,8 @@ int main(int argc, char* argv[]) {
   for (size_t j = 0; j < points.size(); ++j) {
     auto smart = boost::dynamic_pointer_cast<SmartFactor>(graph[j]);
     if (smart) {
-      boost::optional<Point3> point = smart->point(result);
-      if (point)  // ignore if boost::optional return nullptr
+      std::optional<Point3> point = smart->point(result);
+      if (point)  // ignore if std::optional return nullptr
         landmark_result.insert(j, *point);
     }
   }
diff --git a/examples/TriangulationLOSTExample.cpp b/examples/TriangulationLOSTExample.cpp
index a862026e0..4bb280dd1 100644
--- a/examples/TriangulationLOSTExample.cpp
+++ b/examples/TriangulationLOSTExample.cpp
@@ -29,6 +29,7 @@
 #include <chrono>
 #include <iostream>
 #include <random>
+#include <optional>
 
 using namespace std;
 using namespace gtsam;
@@ -131,23 +132,23 @@ int main(int argc, char* argv[]) {
         AddNoiseToMeasurements(measurements, measurementSigma);
 
     auto lostStart = std::chrono::high_resolution_clock::now();
-    boost::optional<Point3> estimateLOST = triangulatePoint3<Cal3_S2>(
+    auto estimateLOST = triangulatePoint3<Cal3_S2>(
         cameras, noisyMeasurements, rank_tol, false, measurementNoise, true);
     durationLOST += std::chrono::high_resolution_clock::now() - lostStart;
 
     auto dltStart = std::chrono::high_resolution_clock::now();
-    boost::optional<Point3> estimateDLT = triangulatePoint3<Cal3_S2>(
+    auto estimateDLT = triangulatePoint3<Cal3_S2>(
         cameras, noisyMeasurements, rank_tol, false, measurementNoise, false);
     durationDLT += std::chrono::high_resolution_clock::now() - dltStart;
 
     auto dltOptStart = std::chrono::high_resolution_clock::now();
-    boost::optional<Point3> estimateDLTOpt = triangulatePoint3<Cal3_S2>(
+    auto estimateDLTOpt = triangulatePoint3<Cal3_S2>(
         cameras, noisyMeasurements, rank_tol, true, measurementNoise, false);
     durationDLTOpt += std::chrono::high_resolution_clock::now() - dltOptStart;
 
-    errorsLOST.row(i) = *estimateLOST - landmark;
-    errorsDLT.row(i) = *estimateDLT - landmark;
-    errorsDLTOpt.row(i) = *estimateDLTOpt - landmark;
+    errorsLOST.row(i) = estimateLOST - landmark;
+    errorsDLT.row(i) = estimateDLT - landmark;
+    errorsDLTOpt.row(i) = estimateDLTOpt - landmark;
   }
   PrintCovarianceStats(errorsLOST, "LOST");
   PrintCovarianceStats(errorsDLT, "DLT");
diff --git a/gtsam/base/Lie.h b/gtsam/base/Lie.h
index c4eba5deb..1b574816a 100644
--- a/gtsam/base/Lie.h
+++ b/gtsam/base/Lie.h
@@ -54,14 +54,14 @@ struct LieGroup {
   }
 
   Class compose(const Class& g, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) const {
+      ChartJacobian H2 = {}) const {
     if (H1) *H1 = g.inverse().AdjointMap();
     if (H2) *H2 = Eigen::Matrix<double, N, N>::Identity();
     return derived() * g;
   }
 
   Class between(const Class& g, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) const {
+      ChartJacobian H2 = {}) const {
     Class result = derived().inverse() * g;
     if (H1) *H1 = - result.inverse().AdjointMap();
     if (H2) *H2 = Eigen::Matrix<double, N, N>::Identity();
@@ -87,7 +87,7 @@ struct LieGroup {
 
   /// expmap with optional derivatives
   Class expmap(const TangentVector& v, //
-      ChartJacobian H1, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1, ChartJacobian H2 = {}) const {
     Jacobian D_g_v;
     Class g = Class::Expmap(v,H2 ? &D_g_v : 0);
     Class h = compose(g); // derivatives inlined below
@@ -98,7 +98,7 @@ struct LieGroup {
 
   /// logmap with optional derivatives
   TangentVector logmap(const Class& g, //
-      ChartJacobian H1, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1, ChartJacobian H2 = {}) const {
     Class h = between(g); // derivatives inlined below
     Jacobian D_v_h;
     TangentVector v = Class::Logmap(h, (H1 || H2) ? &D_v_h : 0);
@@ -139,7 +139,7 @@ struct LieGroup {
 
   /// retract with optional derivatives
   Class retract(const TangentVector& v, //
-      ChartJacobian H1, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1, ChartJacobian H2 = {}) const {
     Jacobian D_g_v;
     Class g = Class::ChartAtOrigin::Retract(v, H2 ? &D_g_v : 0);
     Class h = compose(g); // derivatives inlined below
@@ -150,7 +150,7 @@ struct LieGroup {
 
   /// localCoordinates with optional derivatives
   TangentVector localCoordinates(const Class& g, //
-      ChartJacobian H1, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1, ChartJacobian H2 = {}) const {
     Class h = between(g); // derivatives inlined below
     Jacobian D_v_h;
     TangentVector v = Class::ChartAtOrigin::Local(h, (H1 || H2) ? &D_v_h : 0);
@@ -188,38 +188,38 @@ struct LieGroupTraits: GetDimensionImpl<Class, Class::dimension> {
   typedef OptionalJacobian<dimension, dimension> ChartJacobian;
 
   static TangentVector Local(const Class& origin, const Class& other,
-      ChartJacobian Horigin = boost::none, ChartJacobian Hother = boost::none) {
+      ChartJacobian Horigin = {}, ChartJacobian Hother = {}) {
     return origin.localCoordinates(other, Horigin, Hother);
   }
 
   static Class Retract(const Class& origin, const TangentVector& v,
-      ChartJacobian Horigin = boost::none, ChartJacobian Hv = boost::none) {
+      ChartJacobian Horigin = {}, ChartJacobian Hv = {}) {
     return origin.retract(v, Horigin, Hv);
   }
   /// @}
 
   /// @name Lie Group
   /// @{
-  static TangentVector Logmap(const Class& m, ChartJacobian Hm = boost::none) {
+  static TangentVector Logmap(const Class& m, ChartJacobian Hm = {}) {
     return Class::Logmap(m, Hm);
   }
 
-  static Class Expmap(const TangentVector& v, ChartJacobian Hv = boost::none) {
+  static Class Expmap(const TangentVector& v, ChartJacobian Hv = {}) {
     return Class::Expmap(v, Hv);
   }
 
   static Class Compose(const Class& m1, const Class& m2, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     return m1.compose(m2, H1, H2);
   }
 
   static Class Between(const Class& m1, const Class& m2, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     return m1.between(m2, H1, H2);
   }
 
   static Class Inverse(const Class& m, //
-      ChartJacobian H = boost::none) {
+      ChartJacobian H = {}) {
     return m.inverse(H);
   }
   /// @}
@@ -325,8 +325,8 @@ T expm(const Vector& x, int K=7) {
  */
 template <typename T>
 T interpolate(const T& X, const T& Y, double t,
-              typename MakeOptionalJacobian<T, T>::type Hx = boost::none,
-              typename MakeOptionalJacobian<T, T>::type Hy = boost::none) {
+              typename MakeOptionalJacobian<T, T>::type Hx = {},
+              typename MakeOptionalJacobian<T, T>::type Hy = {}) {
   if (Hx || Hy) {
     typename MakeJacobian<T, T>::type between_H_x, log_H, exp_H, compose_H_x;
     const T between =
diff --git a/gtsam/base/Matrix.h b/gtsam/base/Matrix.h
index cfedf6d8c..88714d6f6 100644
--- a/gtsam/base/Matrix.h
+++ b/gtsam/base/Matrix.h
@@ -459,8 +459,8 @@ struct MultiplyWithInverse {
 
   /// A.inverse() * b, with optional derivatives
   VectorN operator()(const MatrixN& A, const VectorN& b,
-                     OptionalJacobian<N, N* N> H1 = boost::none,
-                     OptionalJacobian<N, N> H2 = boost::none) const {
+                     OptionalJacobian<N, N* N> H1 = {},
+                     OptionalJacobian<N, N> H2 = {}) const {
     const MatrixN invA = A.inverse();
     const VectorN c = invA * b;
     // The derivative in A is just -[c[0]*invA c[1]*invA ... c[N-1]*invA]
@@ -495,16 +495,16 @@ struct MultiplyWithInverseFunction {
 
   /// f(a).inverse() * b, with optional derivatives
   VectorN operator()(const T& a, const VectorN& b,
-                     OptionalJacobian<N, M> H1 = boost::none,
-                     OptionalJacobian<N, N> H2 = boost::none) const {
+                     OptionalJacobian<N, M> H1 = {},
+                     OptionalJacobian<N, N> H2 = {}) const {
     MatrixN A;
-    phi_(a, b, boost::none, A);  // get A = f(a) by calling f once
+    phi_(a, b, {}, A);  // get A = f(a) by calling f once
     const MatrixN invA = A.inverse();
     const VectorN c = invA * b;
 
     if (H1) {
       Eigen::Matrix<double, N, M> H;
-      phi_(a, c, H, boost::none);  // get derivative H of forward mapping
+      phi_(a, c, H, {});  // get derivative H of forward mapping
       *H1 = -invA* H;
     }
     if (H2) *H2 = invA;
diff --git a/gtsam/base/OptionalJacobian.h b/gtsam/base/OptionalJacobian.h
index 4bde4e5e7..22a17e131 100644
--- a/gtsam/base/OptionalJacobian.h
+++ b/gtsam/base/OptionalJacobian.h
@@ -18,23 +18,20 @@
  */
 
 #pragma once
+#include <cstddef>
+#include <functional>
 #include <gtsam/config.h>      // Configuration from CMake
 #include <Eigen/Dense>
+#include <optional>
 #include <stdexcept>
 #include <string>
 
-#ifndef OPTIONALJACOBIAN_NOBOOST
-#include <boost/optional.hpp>
-#endif
-
 namespace gtsam {
 
 /**
  * OptionalJacobian is an Eigen::Ref like class that can take be constructed using
  * either a fixed size or dynamic Eigen matrix. In the latter case, the dynamic
- * matrix will be resized. Finally, there is a constructor that takes
- * boost::none, the default constructor acts like boost::none, and
- * boost::optional<Eigen::MatrixXd&> is also supported for backwards compatibility.
+ * matrix will be resized.
  * Below this class, a dynamic version is also implemented.
  */
 template<int Rows, int Cols>
@@ -66,11 +63,18 @@ private:
 
 public:
 
-  /// Default constructor acts like boost::none
+  /// Default constructor
   OptionalJacobian() :
       map_(nullptr) {
   }
 
+  /// Default constructor with nullptr_t
+  /// To guide the compiler when nullptr
+  /// is passed to args of the type OptionalJacobian
+  OptionalJacobian(std::nullptr_t /*unused*/) :
+      map_(nullptr) {
+  }
+
   /// Constructor that will usurp data of a fixed-size matrix
   OptionalJacobian(Jacobian& fixed) :
       map_(nullptr) {
@@ -116,26 +120,21 @@ public:
                       "Expected: ") +
           "(" + std::to_string(Rows) + ", " + std::to_string(Cols) + ")");
     }
-  }
+  } 
 
-#ifndef OPTIONALJACOBIAN_NOBOOST
-
-  /// Constructor with boost::none just makes empty
-  OptionalJacobian(boost::none_t /*none*/) :
+  /// Constructor with std::nullopt just makes empty
+  OptionalJacobian(std::nullopt_t /*none*/) :
       map_(nullptr) {
   }
 
   /// Constructor compatible with old-style derivatives
-  OptionalJacobian(const boost::optional<Eigen::MatrixXd&> optional) :
+  OptionalJacobian(const std::optional<std::reference_wrapper<Eigen::MatrixXd>> optional) :
       map_(nullptr) {
     if (optional) {
-      optional->resize(Rows, Cols);
-      usurp(optional->data());
+      optional->get().resize(Rows, Cols);
+      usurp(optional->get().data());
     }
   }
-
-#endif
-
   /// Constructor that will usurp data of a block expression
   /// TODO(frank): unfortunately using a Map makes usurping non-contiguous memory impossible
   //  template <typename Derived, bool InnerPanel>
@@ -200,7 +199,7 @@ private:
 
 public:
 
-  /// Default constructor acts like boost::none
+  /// Default constructor 
   OptionalJacobian() :
     pointer_(nullptr) {
   }
@@ -211,21 +210,17 @@ public:
   /// Construct from refrence to dynamic matrix
   OptionalJacobian(Jacobian& dynamic) : pointer_(&dynamic) {}
 
-#ifndef OPTIONALJACOBIAN_NOBOOST
-
-  /// Constructor with boost::none just makes empty
-  OptionalJacobian(boost::none_t /*none*/) :
+  /// Constructor with std::nullopt just makes empty
+  OptionalJacobian(std::nullopt_t /*none*/) :
     pointer_(nullptr) {
   }
 
-  /// Constructor compatible with old-style derivatives
-  OptionalJacobian(const boost::optional<Eigen::MatrixXd&> optional) :
+  /// Constructor for optional matrix reference
+  OptionalJacobian(const std::optional<std::reference_wrapper<Eigen::MatrixXd>> optional) :
       pointer_(nullptr) {
-    if (optional) pointer_ = &(*optional);
+    if (optional) pointer_ = &((*optional).get());
   }
 
-#endif
-
   /// Return true if allocated, false if default constructor was used
   operator bool() const {
     return pointer_!=nullptr;
diff --git a/gtsam/base/ProductLieGroup.h b/gtsam/base/ProductLieGroup.h
index 6689c11d6..831968bc8 100644
--- a/gtsam/base/ProductLieGroup.h
+++ b/gtsam/base/ProductLieGroup.h
@@ -75,14 +75,14 @@ public:
   typedef OptionalJacobian<dimension, dimension> ChartJacobian;
 
   ProductLieGroup retract(const TangentVector& v, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) const {
     if (H1||H2) throw std::runtime_error("ProductLieGroup::retract derivatives not implemented yet");
     G g = traits<G>::Retract(this->first, v.template head<dimension1>());
     H h = traits<H>::Retract(this->second, v.template tail<dimension2>());
     return ProductLieGroup(g,h);
   }
   TangentVector localCoordinates(const ProductLieGroup& g, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) const {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) const {
     if (H1||H2) throw std::runtime_error("ProductLieGroup::localCoordinates derivatives not implemented yet");
     typename traits<G>::TangentVector v1 = traits<G>::Local(this->first, g.first);
     typename traits<H>::TangentVector v2 = traits<H>::Local(this->second, g.second);
@@ -101,7 +101,7 @@ protected:
 
 public:
   ProductLieGroup compose(const ProductLieGroup& other, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) const {
+      ChartJacobian H2 = {}) const {
     Jacobian1 D_g_first; Jacobian2 D_h_second;
     G g = traits<G>::Compose(this->first,other.first, H1 ? &D_g_first : 0);
     H h = traits<H>::Compose(this->second,other.second, H1 ? &D_h_second : 0);
@@ -114,7 +114,7 @@ public:
     return ProductLieGroup(g,h);
   }
   ProductLieGroup between(const ProductLieGroup& other, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) const {
+      ChartJacobian H2 = {}) const {
     Jacobian1 D_g_first; Jacobian2 D_h_second;
     G g = traits<G>::Between(this->first,other.first, H1 ? &D_g_first : 0);
     H h = traits<H>::Between(this->second,other.second, H1 ? &D_h_second : 0);
@@ -137,7 +137,7 @@ public:
     }
     return ProductLieGroup(g,h);
   }
-  static ProductLieGroup Expmap(const TangentVector& v, ChartJacobian Hv = boost::none) {
+  static ProductLieGroup Expmap(const TangentVector& v, ChartJacobian Hv = {}) {
     Jacobian1 D_g_first; Jacobian2 D_h_second;
     G g = traits<G>::Expmap(v.template head<dimension1>(), Hv ? &D_g_first : 0);
     H h = traits<H>::Expmap(v.template tail<dimension2>(), Hv ? &D_h_second : 0);
@@ -148,7 +148,7 @@ public:
     }
     return ProductLieGroup(g,h);
   }
-  static TangentVector Logmap(const ProductLieGroup& p, ChartJacobian Hp = boost::none) {
+  static TangentVector Logmap(const ProductLieGroup& p, ChartJacobian Hp = {}) {
     Jacobian1 D_g_first; Jacobian2 D_h_second;
     typename traits<G>::TangentVector v1 = traits<G>::Logmap(p.first, Hp ? &D_g_first : 0);
     typename traits<H>::TangentVector v2 = traits<H>::Logmap(p.second, Hp ? &D_h_second : 0);
@@ -161,7 +161,7 @@ public:
     }
     return v;
   }
-  static TangentVector LocalCoordinates(const ProductLieGroup& p, ChartJacobian Hp = boost::none) {
+  static TangentVector LocalCoordinates(const ProductLieGroup& p, ChartJacobian Hp = {}) {
     return Logmap(p, Hp);
   }
   ProductLieGroup expmap(const TangentVector& v) const {
diff --git a/gtsam/base/TestableAssertions.h b/gtsam/base/TestableAssertions.h
index 638096c95..b5068ad95 100644
--- a/gtsam/base/TestableAssertions.h
+++ b/gtsam/base/TestableAssertions.h
@@ -20,7 +20,8 @@
 #include <gtsam/base/Testable.h>
 #include <gtsam/global_includes.h>
 
-#include <boost/optional.hpp>
+#include <functional>
+#include <optional>
 #include <map>
 #include <iostream>
 #include <sstream>
@@ -40,21 +41,21 @@ inline bool assert_equal(const Key& expected, const Key& actual, double tol = 0.
 }
 
 /**
- * Comparisons for boost.optional objects that checks whether objects exist
+ * Comparisons for std.optional objects that checks whether objects exist
  * before comparing their values. First version allows for both to be
- * boost::none, but the second, with expected given rather than optional
+ * std::nullopt, but the second, with expected given rather than optional
  *
  * Concept requirement: V is testable
  */
 template<class V>
-bool assert_equal(const boost::optional<V>& expected,
-                  const boost::optional<V>& actual, double tol = 1e-9) {
+bool assert_equal(const std::optional<V>& expected,
+                  const std::optional<V>& actual, double tol = 1e-9) {
   if (!expected && actual) {
-    std::cout << "expected is boost::none, while actual is not" << std::endl;
+    std::cout << "expected is {}, while actual is not" << std::endl;
     return false;
   }
   if (expected && !actual) {
-    std::cout << "actual is boost::none, while expected is not" << std::endl;
+    std::cout << "actual is {}, while expected is not" << std::endl;
     return false;
   }
   if (!expected && !actual)
@@ -63,21 +64,22 @@ bool assert_equal(const boost::optional<V>& expected,
 }
 
 template<class V>
-bool assert_equal(const V& expected, const boost::optional<V>& actual, double tol = 1e-9) {
+bool assert_equal(const V& expected, const std::optional<V>& actual, double tol = 1e-9) {
   if (!actual) {
-    std::cout << "actual is boost::none" << std::endl;
+    std::cout << "actual is {}" << std::endl;
     return false;
   }
   return assert_equal(expected, *actual, tol);
 }
 
 template<class V>
-bool assert_equal(const V& expected, const boost::optional<const V&>& actual, double tol = 1e-9) {
+bool assert_equal(const V& expected, 
+    const std::optional<std::reference_wrapper<const V>>& actual, double tol = 1e-9) {
   if (!actual) {
-    std::cout << "actual is boost::none" << std::endl;
+    std::cout << "actual is std::nullopt" << std::endl;
     return false;
   }
-  return assert_equal(expected, *actual, tol);
+  return assert_equal(expected, *actual.get(), tol);
 }
 
 /**
diff --git a/gtsam/base/ThreadsafeException.h b/gtsam/base/ThreadsafeException.h
index 652dbd90f..57e37237f 100644
--- a/gtsam/base/ThreadsafeException.h
+++ b/gtsam/base/ThreadsafeException.h
@@ -21,11 +21,11 @@
 
 #include <gtsam/config.h> // for GTSAM_USE_TBB
 
-#include <boost/optional/optional.hpp>
 #include <gtsam/dllexport.h>
 #include <string>
 #include <typeinfo>
 #include <exception>
+#include <optional>
 
 #ifdef GTSAM_USE_TBB
 #include <tbb/tbb_allocator.h>
@@ -53,7 +53,7 @@ protected:
 
 protected:
   bool dynamic_; ///< Whether this object was moved
-  mutable boost::optional<String> description_; ///< Optional description
+  mutable std::optional<String> description_; ///< Optional description
 
   /// Default constructor is protected - may only be created from derived classes
   ThreadsafeException() :
diff --git a/gtsam/base/Value.h b/gtsam/base/Value.h
index 697c4f3be..0d2c601cd 100644
--- a/gtsam/base/Value.h
+++ b/gtsam/base/Value.h
@@ -21,6 +21,7 @@
 #include <gtsam/config.h>      // Configuration from CMake
 
 #include <gtsam/base/Vector.h>
+#include <boost/make_shared.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/assume_abstract.hpp>
 #include <memory>
diff --git a/gtsam/base/Vector.cpp b/gtsam/base/Vector.cpp
index 16d913a96..ce7aeba7b 100644
--- a/gtsam/base/Vector.cpp
+++ b/gtsam/base/Vector.cpp
@@ -18,7 +18,6 @@
  */
 
 #include <gtsam/base/Vector.h>
-#include <boost/optional.hpp>
 #include <stdexcept>
 #include <cstdarg>
 #include <limits>
diff --git a/gtsam/base/VectorSpace.h b/gtsam/base/VectorSpace.h
index f7809f596..9fbd581bb 100644
--- a/gtsam/base/VectorSpace.h
+++ b/gtsam/base/VectorSpace.h
@@ -32,7 +32,7 @@ struct VectorSpaceImpl {
   static int GetDimension(const Class&) { return N;}
 
   static TangentVector Local(const Class& origin, const Class& other,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = - Jacobian::Identity();
     if (H2) *H2 = Jacobian::Identity();
     Class v = other-origin;
@@ -40,7 +40,7 @@ struct VectorSpaceImpl {
   }
 
   static Class Retract(const Class& origin, const TangentVector& v,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = Jacobian::Identity();
     if (H2) *H2 = Jacobian::Identity();
     return origin + v;
@@ -51,31 +51,31 @@ struct VectorSpaceImpl {
   /// @name Lie Group
   /// @{
 
-  static TangentVector Logmap(const Class& m, ChartJacobian Hm = boost::none) {
+  static TangentVector Logmap(const Class& m, ChartJacobian Hm = {}) {
     if (Hm) *Hm = Jacobian::Identity();
     return m.vector();
   }
 
-  static Class Expmap(const TangentVector& v, ChartJacobian Hv = boost::none) {
+  static Class Expmap(const TangentVector& v, ChartJacobian Hv = {}) {
     if (Hv)  *Hv = Jacobian::Identity();
     return Class(v);
   }
 
-  static Class Compose(const Class& v1, const Class& v2, ChartJacobian H1 = boost::none,
-      ChartJacobian H2 = boost::none) {
+  static Class Compose(const Class& v1, const Class& v2, ChartJacobian H1 = {},
+      ChartJacobian H2 = {}) {
     if (H1) *H1 = Jacobian::Identity();
     if (H2) *H2 = Jacobian::Identity();
     return v1 + v2;
   }
 
-  static Class Between(const Class& v1, const Class& v2, ChartJacobian H1 = boost::none,
-      ChartJacobian H2 = boost::none) {
+  static Class Between(const Class& v1, const Class& v2, ChartJacobian H1 = {},
+      ChartJacobian H2 = {}) {
     if (H1) *H1 = - Jacobian::Identity();
     if (H2) *H2 =   Jacobian::Identity();
     return v2 - v1;
   }
 
-  static Class Inverse(const Class& v, ChartJacobian H = boost::none) {
+  static Class Inverse(const Class& v, ChartJacobian H = {}) {
     if (H) *H = - Jacobian::Identity();
     return -v;
   }
@@ -106,7 +106,7 @@ struct VectorSpaceImpl<Class,Eigen::Dynamic> {
   }
 
   static TangentVector Local(const Class& origin, const Class& other,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = - Eye(origin);
     if (H2) *H2 = Eye(other);
     Class v = other-origin;
@@ -114,7 +114,7 @@ struct VectorSpaceImpl<Class,Eigen::Dynamic> {
   }
 
   static Class Retract(const Class& origin, const TangentVector& v,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = Eye(origin);
     if (H2) *H2 = Eye(origin);
     return origin + v;
@@ -125,12 +125,12 @@ struct VectorSpaceImpl<Class,Eigen::Dynamic> {
   /// @name Lie Group
   /// @{
 
-  static TangentVector Logmap(const Class& m, ChartJacobian Hm = boost::none) {
+  static TangentVector Logmap(const Class& m, ChartJacobian Hm = {}) {
     if (Hm) *Hm = Eye(m);
     return m.vector();
   }
 
-  static Class Expmap(const TangentVector& v, ChartJacobian Hv = boost::none) {
+  static Class Expmap(const TangentVector& v, ChartJacobian Hv = {}) {
     Class result(v);
     if (Hv)
       *Hv = Eye(v);
@@ -138,14 +138,14 @@ struct VectorSpaceImpl<Class,Eigen::Dynamic> {
   }
 
   static Class Compose(const Class& v1, const Class& v2, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) {
+      ChartJacobian H2 = {}) {
     if (H1) *H1 = Eye(v1);
     if (H2) *H2 = Eye(v2);
     return v1 + v2;
   }
 
   static Class Between(const Class& v1, const Class& v2, ChartJacobian H1,
-      ChartJacobian H2 = boost::none) {
+      ChartJacobian H2 = {}) {
     if (H1) *H1 = - Eye(v1);
     if (H2) *H2 =   Eye(v2);
     return v2 - v1;
@@ -237,7 +237,7 @@ struct ScalarTraits : VectorSpaceImpl<Scalar, 1> {
   typedef OptionalJacobian<1, 1> ChartJacobian;
 
   static TangentVector Local(Scalar origin, Scalar other,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) (*H1)[0] = -1.0;
     if (H2) (*H2)[0] =  1.0;
     TangentVector result;
@@ -246,7 +246,7 @@ struct ScalarTraits : VectorSpaceImpl<Scalar, 1> {
   }
 
   static Scalar Retract(Scalar origin, const TangentVector& v,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) (*H1)[0] = 1.0;
     if (H2) (*H2)[0] = 1.0;
     return origin + v[0];
@@ -255,12 +255,12 @@ struct ScalarTraits : VectorSpaceImpl<Scalar, 1> {
 
   /// @name Lie Group
   /// @{
-  static TangentVector Logmap(Scalar m, ChartJacobian H = boost::none) {
+  static TangentVector Logmap(Scalar m, ChartJacobian H = {}) {
     if (H) (*H)[0] = 1.0;
     return Local(0, m);
   }
 
-  static Scalar Expmap(const TangentVector& v, ChartJacobian H = boost::none) {
+  static Scalar Expmap(const TangentVector& v, ChartJacobian H = {}) {
     if (H) (*H)[0] = 1.0;
     return v[0];
   }
@@ -312,7 +312,7 @@ struct traits<Eigen::Matrix<double, M, N, Options, MaxRows, MaxCols> > :
   typedef OptionalJacobian<dimension, dimension> ChartJacobian;
 
   static TangentVector Local(const Fixed& origin, const Fixed& other,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) (*H1) = -Jacobian::Identity();
     if (H2) (*H2) =  Jacobian::Identity();
     TangentVector result;
@@ -321,7 +321,7 @@ struct traits<Eigen::Matrix<double, M, N, Options, MaxRows, MaxCols> > :
   }
 
   static Fixed Retract(const Fixed& origin, const TangentVector& v,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) (*H1) = Jacobian::Identity();
     if (H2) (*H2) = Jacobian::Identity();
     return origin + Eigen::Map<const Fixed>(v.data());
@@ -330,14 +330,14 @@ struct traits<Eigen::Matrix<double, M, N, Options, MaxRows, MaxCols> > :
 
   /// @name Lie Group
   /// @{
-  static TangentVector Logmap(const Fixed& m, ChartJacobian H = boost::none) {
+  static TangentVector Logmap(const Fixed& m, ChartJacobian H = {}) {
     if (H) *H = Jacobian::Identity();
     TangentVector result;
     Eigen::Map<Fixed>(result.data()) = m;
     return result;
   }
 
-  static Fixed Expmap(const TangentVector& v, ChartJacobian H = boost::none) {
+  static Fixed Expmap(const TangentVector& v, ChartJacobian H = {}) {
     Fixed m;
     m.setZero();
     if (H) *H = Jacobian::Identity();
@@ -393,7 +393,7 @@ struct DynamicTraits {
   }
 
   static TangentVector Local(const Dynamic& m, const Dynamic& other, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = -Eye(m);
     if (H2) *H2 =  Eye(m);
     TangentVector v(GetDimension(m));
@@ -402,7 +402,7 @@ struct DynamicTraits {
   }
 
   static Dynamic Retract(const Dynamic& m, const TangentVector& v, //
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = Eye(m);
     if (H2) *H2 = Eye(m);
     return m + Eigen::Map<const Dynamic>(v.data(), m.rows(), m.cols());
@@ -411,32 +411,32 @@ struct DynamicTraits {
 
   /// @name Lie Group
   /// @{
-  static TangentVector Logmap(const Dynamic& m, ChartJacobian H = boost::none) {
+  static TangentVector Logmap(const Dynamic& m, ChartJacobian H = {}) {
     if (H) *H = Eye(m);
     TangentVector result(GetDimension(m));
     Eigen::Map<Dynamic>(result.data(), m.cols(), m.rows()) = m;
     return result;
   }
 
-  static Dynamic Expmap(const TangentVector& /*v*/, ChartJacobian H = boost::none) {
+  static Dynamic Expmap(const TangentVector& /*v*/, ChartJacobian H = {}) {
     static_cast<void>(H);
     throw std::runtime_error("Expmap not defined for dynamic types");
   }
 
-  static Dynamic Inverse(const Dynamic& m, ChartJacobian H = boost::none) {
+  static Dynamic Inverse(const Dynamic& m, ChartJacobian H = {}) {
     if (H) *H = -Eye(m);
     return -m;
   }
 
   static Dynamic Compose(const Dynamic& v1, const Dynamic& v2,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = Eye(v1);
     if (H2) *H2 = Eye(v1);
     return v1 + v2;
   }
 
   static Dynamic Between(const Dynamic& v1, const Dynamic& v2,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     if (H1) *H1 = -Eye(v1);
     if (H2) *H2 = Eye(v1);
     return v2 - v1;
diff --git a/gtsam/base/numericalDerivative.h b/gtsam/base/numericalDerivative.h
index e4255bc63..8c9934d77 100644
--- a/gtsam/base/numericalDerivative.h
+++ b/gtsam/base/numericalDerivative.h
@@ -37,8 +37,8 @@ namespace gtsam {
  *   for a function with one relevant param and an optional derivative:
  *     Foo bar(const Obj& a, OptionalMatrixType H1)
  *   Use boost.bind to restructure:
- *     std::bind(bar, std::placeholders::_1, boost::none)
- *   This syntax will fix the optional argument to boost::none, while using the first argument provided
+ *     std::bind(bar, std::placeholders::_1, {})
+ *   This syntax will fix the optional argument to {}, while using the first argument provided
  *
  * For member functions, such as below, with an instantiated copy instanceOfSomeClass
  *     Foo SomeClass::bar(const Obj& a)
diff --git a/gtsam/base/serializationTestHelpers.h b/gtsam/base/serializationTestHelpers.h
index bb8574245..7aab743db 100644
--- a/gtsam/base/serializationTestHelpers.h
+++ b/gtsam/base/serializationTestHelpers.h
@@ -24,6 +24,7 @@
 #include <string>
 
 #include <gtsam/base/serialization.h>
+#include <gtsam/base/TestableAssertions.h>
 
 #include <boost/serialization/serialization.hpp>
 #include <boost/filesystem.hpp>
diff --git a/gtsam/base/std_optional_serialization.h b/gtsam/base/std_optional_serialization.h
new file mode 100644
index 000000000..d4ed4f53d
--- /dev/null
+++ b/gtsam/base/std_optional_serialization.h
@@ -0,0 +1,95 @@
+// Functionality to serialize std::optional<T> to boost::archive
+// Following this:
+// PR: https://github.com/boostorg/serialization/pull/148/files#
+
+#pragma once
+#include <optional>
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/move/utility_core.hpp>
+
+#include <boost/serialization/item_version_type.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/detail/is_default_constructible.hpp>
+
+/** A bunch of declarations to deal with gcc bug
+ * The compiler has a difficult time distinguisihing between:
+ *
+ * template<template <Archive, class U> class SPT> void load(Archive, SPT<U>&, const unsigned int) : <boost/serialization/shared_ptr.hpp>
+ *
+ * and
+ *
+ * template<T> void load(Archive, std::optional<T>&, const unsigned int) : <std_optional_serialization.h>
+ *
+ * The compiler will try to instantiate an object of the type of std::optional<boost::serialization::U> which is not valid since U is not a type and
+ * thus leading to a whole series of errros.
+ *
+ * This is a well known bug in gcc documented here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84075
+ * A minimal reproducible example here: https://godbolt.org/z/anj9YjnPY
+ *
+ * For std::optional the workaround is just provide the traits needed to make std::optional<boost::serialization::U> possible
+ * This is not an issue since there is no actual type boost::serialization::U and we are not falsely providing a specialization
+ * for std::optional<boost::serialization::U>
+ */
+#ifdef __GNUC__
+#if __GNUC__ >= 7 && __cplusplus >= 201703L
+namespace boost { namespace serialization { struct U; } }
+namespace std { template<> struct is_trivially_default_constructible<boost::serialization::U> : std::false_type {}; }
+namespace std { template<> struct is_trivially_copy_constructible<boost::serialization::U> : std::false_type {}; }
+namespace std { template<> struct is_trivially_move_constructible<boost::serialization::U> : std::false_type {}; }
+#endif
+#endif
+
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+namespace boost {
+namespace serialization {
+
+template <class Archive, class T>
+void save(Archive& ar, const std::optional<T>& t, const unsigned int /*version*/
+) {
+  // It is an inherent limitation to the serialization of optional.hpp
+  // that the underlying type must be either a pointer or must have a
+  // default constructor.
+  BOOST_STATIC_ASSERT(boost::serialization::detail::is_default_constructible<T>::value || boost::is_pointer<T>::value);
+  const bool tflag = t.has_value();
+  ar << boost::serialization::make_nvp("initialized", tflag);
+  if (tflag) {
+    ar << boost::serialization::make_nvp("value", *t);
+  }
+}
+
+template <class Archive, class T>
+void load(Archive& ar, std::optional<T>& t, const unsigned int /*version*/
+) {
+  bool tflag;
+  ar >> boost::serialization::make_nvp("initialized", tflag);
+  if (!tflag) {
+    t.reset();
+    return;
+  }
+
+  if (!t.has_value()) {
+    // Need to be default constructible
+    t.emplace();
+  }
+  ar >> boost::serialization::make_nvp("value", *t);
+}
+
+template <class Archive, class T>
+void serialize(Archive& ar, std::optional<T>& t, const unsigned int version) {
+  boost::serialization::split_free(ar, t, version);
+}
+
+// derive boost::xml_archive_impl for archiving std::optional<T> with xml
+
+}  // namespace serialization
+}  // namespace boost
+
diff --git a/gtsam/base/tests/testMatrix.cpp b/gtsam/base/tests/testMatrix.cpp
index 7802f27e1..fb3bd948c 100644
--- a/gtsam/base/tests/testMatrix.cpp
+++ b/gtsam/base/tests/testMatrix.cpp
@@ -23,6 +23,8 @@
 #include <boost/tuple/tuple.hpp>
 #include <iostream>
 #include <sstream>
+#include <optional>
+#include <functional>
 
 using namespace std;
 using namespace gtsam;
@@ -1176,6 +1178,17 @@ TEST(Matrix, AbsoluteError) {
   EXPECT(isEqual);
 }
 
+// A test to check if a matrix and an optional reference_wrapper to
+// a matrix are equal.
+TEST(Matrix, MatrixRef) {
+  Matrix A = Matrix::Random(3, 3);
+  Matrix B = Matrix::Random(3, 3);
+
+  EXPECT(assert_equal(A, A));
+  EXPECT(assert_equal(A, std::cref(A)));
+  EXPECT(!assert_equal(A, std::cref(B)));
+}
+
 /* ************************************************************************* */
 int main() {
   TestResult tr;
diff --git a/gtsam/base/tests/testOptionalJacobian.cpp b/gtsam/base/tests/testOptionalJacobian.cpp
index ae91642f4..4c775af75 100644
--- a/gtsam/base/tests/testOptionalJacobian.cpp
+++ b/gtsam/base/tests/testOptionalJacobian.cpp
@@ -20,6 +20,9 @@
 #include <gtsam/base/OptionalJacobian.h>
 #include <CppUnitLite/TestHarness.h>
 
+#include <optional>
+#include <functional>
+
 using namespace std;
 using namespace gtsam;
 
@@ -32,7 +35,7 @@ using namespace gtsam;
 TEST( OptionalJacobian, Constructors ) {
   Matrix23 fixed;
   Matrix dynamic;
-  boost::optional<Matrix&> optional(dynamic);
+  std::optional<std::reference_wrapper<Matrix>> optionalRef(std::ref(dynamic));
 
   OptionalJacobian<2, 3> H;
   EXPECT(!H);
@@ -41,22 +44,23 @@ TEST( OptionalJacobian, Constructors ) {
   TEST_CONSTRUCTOR(2, 3, &fixed, true);
   TEST_CONSTRUCTOR(2, 3, dynamic, true);
   TEST_CONSTRUCTOR(2, 3, &dynamic, true);
-  TEST_CONSTRUCTOR(2, 3, boost::none, false);
-  TEST_CONSTRUCTOR(2, 3, optional, true);
+  TEST_CONSTRUCTOR(2, 3, std::nullopt, false);
+  TEST_CONSTRUCTOR(2, 3, optionalRef, true);
 
   // Test dynamic
   OptionalJacobian<-1, -1> H7;
   EXPECT(!H7);
 
   TEST_CONSTRUCTOR(-1, -1, dynamic, true);
-  TEST_CONSTRUCTOR(-1, -1, boost::none, false);
-  TEST_CONSTRUCTOR(-1, -1, optional, true);
+  TEST_CONSTRUCTOR(-1, -1, std::nullopt, false);
+  TEST_CONSTRUCTOR(-1, -1, optionalRef, true);
+
 }
 
 //******************************************************************************
 Matrix kTestMatrix = (Matrix23() << 11,12,13,21,22,23).finished();
 
-void test(OptionalJacobian<2, 3> H = boost::none) {
+void test(OptionalJacobian<2, 3> H = {}) {
   if (H)
     *H = kTestMatrix;
 }
@@ -116,7 +120,7 @@ TEST( OptionalJacobian, Fixed) {
 }
 
 //******************************************************************************
-void test2(OptionalJacobian<-1,-1> H = boost::none) {
+void test2(OptionalJacobian<-1,-1> H = {}) {
   if (H)
     *H = kTestMatrix; // resizes
 }
@@ -145,12 +149,12 @@ TEST( OptionalJacobian, Dynamic) {
 }
 
 //******************************************************************************
-void test3(double add, OptionalJacobian<2,1> H = boost::none) {
+void test3(double add, OptionalJacobian<2,1> H = {}) {
   if (H) *H << add + 10, add + 20;
 }
 
 // This function calls the above function three times, one for each column
-void test4(OptionalJacobian<2, 3> H = boost::none) {
+void test4(OptionalJacobian<2, 3> H = {}) {
   if (H) {
     test3(1, H.cols<1>(0));
     test3(2, H.cols<1>(1));
diff --git a/gtsam/base/tests/testSerializationBase.cpp b/gtsam/base/tests/testSerializationBase.cpp
index d2f4d5f51..9387d9b59 100644
--- a/gtsam/base/tests/testSerializationBase.cpp
+++ b/gtsam/base/tests/testSerializationBase.cpp
@@ -28,6 +28,7 @@
 #include <gtsam/base/FastVector.h>
 
 #include <gtsam/base/serializationTestHelpers.h>
+#include <gtsam/base/std_optional_serialization.h>
 #include <CppUnitLite/TestHarness.h>
 
 using namespace std;
diff --git a/gtsam/base/tests/testStdOptionalSerialization.cpp b/gtsam/base/tests/testStdOptionalSerialization.cpp
new file mode 100644
index 000000000..dd99b0f12
--- /dev/null
+++ b/gtsam/base/tests/testStdOptionalSerialization.cpp
@@ -0,0 +1,157 @@
+#include <CppUnitLite/TestHarness.h>
+
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+
+#include "gtsam/base/serializationTestHelpers.h"
+#include "gtsam/base/std_optional_serialization.h"
+
+using namespace gtsam;
+
+// A test to check that the serialization of std::optional works with boost
+TEST(StdOptionalSerialization, SerializeIntOptional) {
+  // Create an optional
+  std::optional<int> opt(42);
+
+  // Serialize it
+  std::stringstream ss;
+  boost::archive::text_oarchive oa(ss);
+  oa << opt;
+
+  // Deserialize it
+  std::optional<int> opt2;
+  boost::archive::text_iarchive ia(ss);
+  ia >> opt2;
+
+  // Check that it worked
+  EXPECT(opt2.has_value());
+  EXPECT(*opt2 == 42);
+}
+
+// A test to check if we serialize an empty optional, it is deserialized as an
+// empty optional
+TEST(StdOptionalSerialization, SerializeEmptyOptional) {
+  // Create an optional
+  std::optional<int> opt;
+
+  // Serialize it
+  std::stringstream ss;
+  boost::archive::text_oarchive oa(ss);
+  oa << opt;
+
+  // Deserialize it
+  std::optional<int> opt2 = 43;
+  boost::archive::text_iarchive ia(ss);
+  ia >> opt2;
+
+  // Check that it worked
+  EXPECT(!opt2.has_value());
+}
+
+/* ************************************************************************* */
+// Implement the equals trait for TestOptionalStruct
+namespace gtsam {
+// A struct which contains an optional
+class TestOptionalStruct {
+public:
+  std::optional<int> opt;
+  TestOptionalStruct() = default;
+  TestOptionalStruct(const int& opt)
+      : opt(opt) {}
+  // A copy constructor is needed for serialization
+  TestOptionalStruct(const TestOptionalStruct& other) = default;
+  bool operator==(const TestOptionalStruct& other) const {
+    // check the values are equal
+    return *opt == *other.opt;
+  }
+  friend class boost::serialization::access;
+  template <class Archive>
+  void serialize(Archive& ar, const unsigned int /*version*/) {
+    ar& BOOST_SERIALIZATION_NVP(opt);
+  }
+};
+
+template <>
+struct traits<TestOptionalStruct> {
+  static bool Equals(const TestOptionalStruct& q1, const TestOptionalStruct& q2, double) {
+    // if both have values then compare the values
+    if (q1.opt.has_value() && q2.opt.has_value()) {
+      return *q1.opt == *q2.opt;
+    }
+    // otherwise check that both are empty
+    return q1.opt == q2.opt;
+  }
+
+  static void Print(const TestOptionalStruct& m, const std::string& s = "") {
+    /* std::cout << s << "opt: " << m.opt << std::endl; */
+    if (m.opt.has_value()) {
+      std::cout << s << "opt: " << *m.opt << std::endl;
+    } else {
+      std::cout << s << "opt: empty" << std::endl;
+    }
+  }
+};
+}  // namespace gtsam
+
+// Test for a struct with an initialized optional
+TEST(StdOptionalSerialization, SerializTestOptionalStruct) {
+  TestOptionalStruct optStruct(10);
+  EXPECT(serializationTestHelpers::equalsObj(optStruct));
+  EXPECT(serializationTestHelpers::equalsXML(optStruct));
+  EXPECT(serializationTestHelpers::equalsBinary(optStruct));
+}
+
+// Test for a struct with an uninitialized optional
+TEST(StdOptionalSerialization, SerializTestOptionalStructUninitialized) {
+  TestOptionalStruct optStruct;
+  EXPECT(serializationTestHelpers::equalsObj(optStruct));
+  EXPECT(serializationTestHelpers::equalsXML(optStruct));
+  EXPECT(serializationTestHelpers::equalsBinary(optStruct));
+}
+
+// Test for serialization of std::optional<TestOptionalStruct> 
+TEST(StdOptionalSerialization, SerializTestOptionalStructPointer) {
+  // Create an optional
+  std::optional<TestOptionalStruct> opt(TestOptionalStruct(42));
+
+  // Serialize it
+  std::stringstream ss;
+  boost::archive::text_oarchive oa(ss);
+  oa << opt;
+
+  // Deserialize it
+  std::optional<TestOptionalStruct> opt2;
+  boost::archive::text_iarchive ia(ss);
+  ia >> opt2;
+
+  // Check that it worked
+  EXPECT(opt2.has_value());
+  EXPECT(*opt2 == TestOptionalStruct(42));
+}
+
+// Test for serialization of std::optional<TestOptionalStruct*>
+TEST(StdOptionalSerialization, SerializTestOptionalStructPointerPointer) {
+  // Create an optional
+  std::optional<TestOptionalStruct*> opt(new TestOptionalStruct(42));
+
+  // Serialize it
+  std::stringstream ss;
+  boost::archive::text_oarchive oa(ss);
+  oa << opt;
+
+  // Deserialize it
+  std::optional<TestOptionalStruct*> opt2;
+  boost::archive::text_iarchive ia(ss);
+  ia >> opt2;
+
+  // Check that it worked
+  EXPECT(opt2.has_value());
+  EXPECT(**opt2 == TestOptionalStruct(42));
+}
+
+int main() {
+  TestResult tr;
+  return TestRegistry::runAllTests(tr);
+}
diff --git a/gtsam/basis/Basis.h b/gtsam/basis/Basis.h
index d517078f1..97704dab4 100644
--- a/gtsam/basis/Basis.h
+++ b/gtsam/basis/Basis.h
@@ -152,14 +152,14 @@ class Basis {
 
     /// Regular 1D evaluation
     double apply(const typename DERIVED::Parameters& p,
-                 OptionalJacobian<-1, -1> H = boost::none) const {
+                 OptionalJacobian<-1, -1> H = {}) const {
       if (H) *H = weights_;
       return (weights_ * p)(0);
     }
 
     /// c++ sugar
     double operator()(const typename DERIVED::Parameters& p,
-                      OptionalJacobian<-1, -1> H = boost::none) const {
+                      OptionalJacobian<-1, -1> H = {}) const {
       return apply(p, H);  // might call apply in derived
     }
 
@@ -212,14 +212,14 @@ class Basis {
 
     /// M-dimensional evaluation
     VectorM apply(const ParameterMatrix<M>& P,
-                  OptionalJacobian</*MxN*/ -1, -1> H = boost::none) const {
+                  OptionalJacobian</*MxN*/ -1, -1> H = {}) const {
       if (H) *H = H_;
       return P.matrix() * this->weights_.transpose();
     }
 
     /// c++ sugar
     VectorM operator()(const ParameterMatrix<M>& P,
-                       OptionalJacobian</*MxN*/ -1, -1> H = boost::none) const {
+                       OptionalJacobian</*MxN*/ -1, -1> H = {}) const {
       return apply(P, H);
     }
   };
@@ -271,14 +271,14 @@ class Basis {
 
     /// Calculate component of component rowIndex_ of P
     double apply(const ParameterMatrix<M>& P,
-                 OptionalJacobian</*1xMN*/ -1, -1> H = boost::none) const {
+                 OptionalJacobian</*1xMN*/ -1, -1> H = {}) const {
       if (H) *H = H_;
       return P.row(rowIndex_) * EvaluationFunctor::weights_.transpose();
     }
 
     /// c++ sugar
     double operator()(const ParameterMatrix<M>& P,
-                      OptionalJacobian</*1xMN*/ -1, -1> H = boost::none) const {
+                      OptionalJacobian</*1xMN*/ -1, -1> H = {}) const {
       return apply(P, H);
     }
   };
@@ -315,7 +315,7 @@ class Basis {
 
     /// Manifold evaluation
     T apply(const ParameterMatrix<M>& P,
-            OptionalJacobian</*MxMN*/ -1, -1> H = boost::none) const {
+            OptionalJacobian</*MxMN*/ -1, -1> H = {}) const {
       // Interpolate the M-dimensional vector to yield a vector in tangent space
       Eigen::Matrix<double, M, 1> xi = Base::operator()(P, H);
 
@@ -334,7 +334,7 @@ class Basis {
 
     /// c++ sugar
     T operator()(const ParameterMatrix<M>& P,
-                 OptionalJacobian</*MxN*/ -1, -1> H = boost::none) const {
+                 OptionalJacobian</*MxN*/ -1, -1> H = {}) const {
       return apply(P, H);  // might call apply in derived
     }
   };
@@ -377,13 +377,13 @@ class Basis {
         : DerivativeFunctorBase(N, x, a, b) {}
 
     double apply(const typename DERIVED::Parameters& p,
-                 OptionalJacobian</*1xN*/ -1, -1> H = boost::none) const {
+                 OptionalJacobian</*1xN*/ -1, -1> H = {}) const {
       if (H) *H = this->weights_;
       return (this->weights_ * p)(0);
     }
     /// c++ sugar
     double operator()(const typename DERIVED::Parameters& p,
-                      OptionalJacobian</*1xN*/ -1, -1> H = boost::none) const {
+                      OptionalJacobian</*1xN*/ -1, -1> H = {}) const {
       return apply(p, H);  // might call apply in derived
     }
   };
@@ -433,14 +433,14 @@ class Basis {
     }
 
     VectorM apply(const ParameterMatrix<M>& P,
-                  OptionalJacobian</*MxMN*/ -1, -1> H = boost::none) const {
+                  OptionalJacobian</*MxMN*/ -1, -1> H = {}) const {
       if (H) *H = H_;
       return P.matrix() * this->weights_.transpose();
     }
     /// c++ sugar
     VectorM operator()(
         const ParameterMatrix<M>& P,
-        OptionalJacobian</*MxMN*/ -1, -1> H = boost::none) const {
+        OptionalJacobian</*MxMN*/ -1, -1> H = {}) const {
       return apply(P, H);
     }
   };
@@ -491,13 +491,13 @@ class Basis {
     }
     /// Calculate derivative of component rowIndex_ of F
     double apply(const ParameterMatrix<M>& P,
-                 OptionalJacobian</*1xMN*/ -1, -1> H = boost::none) const {
+                 OptionalJacobian</*1xMN*/ -1, -1> H = {}) const {
       if (H) *H = H_;
       return P.row(rowIndex_) * this->weights_.transpose();
     }
     /// c++ sugar
     double operator()(const ParameterMatrix<M>& P,
-                      OptionalJacobian</*1xMN*/ -1, -1> H = boost::none) const {
+                      OptionalJacobian</*1xMN*/ -1, -1> H = {}) const {
       return apply(P, H);
     }
   };
diff --git a/gtsam/basis/tests/testChebyshev2.cpp b/gtsam/basis/tests/testChebyshev2.cpp
index 73339e0f1..177ea5b49 100644
--- a/gtsam/basis/tests/testChebyshev2.cpp
+++ b/gtsam/basis/tests/testChebyshev2.cpp
@@ -17,6 +17,7 @@
  *        methods
  */
 
+#include <cstddef>
 #include <gtsam/basis/Chebyshev2.h>
 #include <gtsam/basis/FitBasis.h>
 #include <gtsam/geometry/Pose2.h>
@@ -119,7 +120,7 @@ TEST(Chebyshev2, InterpolateVector) {
 
   // Check derivative
   std::function<Vector2(ParameterMatrix<2>)> f = boost::bind(
-      &Chebyshev2::VectorEvaluationFunctor<2>::operator(), fx, _1, boost::none);
+      &Chebyshev2::VectorEvaluationFunctor<2>::operator(), fx, _1, nullptr);
   Matrix numericalH =
       numericalDerivative11<Vector2, ParameterMatrix<2>, 2 * N>(f, X);
   EXPECT(assert_equal(numericalH, actualH, 1e-9));
@@ -377,7 +378,7 @@ TEST(Chebyshev2, VectorDerivativeFunctor) {
 
   // Test Jacobian
   Matrix expectedH = numericalDerivative11<Vector2, ParameterMatrix<M>, M * N>(
-      boost::bind(&VecD::operator(), fx, _1, boost::none), X);
+      boost::bind(&VecD::operator(), fx, _1, nullptr), X);
   EXPECT(assert_equal(expectedH, actualH, 1e-7));
 }
 
@@ -409,7 +410,7 @@ TEST(Chebyshev2, VectorDerivativeFunctor2) {
   VecD vecd(N, points(0), 0, T);
   vecd(X, actualH);
   Matrix expectedH = numericalDerivative11<Vector1, ParameterMatrix<M>, M * N>(
-      boost::bind(&VecD::operator(), vecd, _1, boost::none), X);
+      boost::bind(&VecD::operator(), vecd, _1, nullptr), X);
   EXPECT(assert_equal(expectedH, actualH, 1e-6));
 }
 
@@ -426,7 +427,7 @@ TEST(Chebyshev2, ComponentDerivativeFunctor) {
   EXPECT_DOUBLES_EQUAL(0, fx(X, actualH), 1e-8);
 
   Matrix expectedH = numericalDerivative11<double, ParameterMatrix<M>, M * N>(
-      boost::bind(&CompFunc::operator(), fx, _1, boost::none), X);
+      boost::bind(&CompFunc::operator(), fx, _1, nullptr), X);
   EXPECT(assert_equal(expectedH, actualH, 1e-7));
 }
 
diff --git a/gtsam/discrete/DecisionTree-inl.h b/gtsam/discrete/DecisionTree-inl.h
index 9f3d5e8f9..0726da3dd 100644
--- a/gtsam/discrete/DecisionTree-inl.h
+++ b/gtsam/discrete/DecisionTree-inl.h
@@ -24,7 +24,6 @@
 #include <algorithm>
 #include <boost/format.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/optional.hpp>
 
 #include <cmath>
 #include <fstream>
@@ -34,6 +33,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <optional>
 
 namespace gtsam {
 
@@ -563,7 +563,7 @@ namespace gtsam {
   typename DecisionTree<L, Y>::NodePtr DecisionTree<L, Y>::compose(
       Iterator begin, Iterator end, const L& label) const {
     // find highest label among branches
-    boost::optional<L> highestLabel;
+    std::optional<L> highestLabel;
     size_t nrChoices = 0;
     for (Iterator it = begin; it != end; it++) {
       if (it->root_->isLeaf())
@@ -571,7 +571,7 @@ namespace gtsam {
       boost::shared_ptr<const Choice> c =
           boost::dynamic_pointer_cast<const Choice>(it->root_);
       if (!highestLabel || c->label() > *highestLabel) {
-        highestLabel.reset(c->label());
+        highestLabel = c->label();
         nrChoices = c->nrChoices();
       }
     }
diff --git a/gtsam/discrete/DiscreteFactorGraph.h b/gtsam/discrete/DiscreteFactorGraph.h
index 3fbb64d50..4441b0df4 100644
--- a/gtsam/discrete/DiscreteFactorGraph.h
+++ b/gtsam/discrete/DiscreteFactorGraph.h
@@ -70,8 +70,8 @@ template<> struct EliminationTraits<DiscreteFactorGraph>
   /// The default ordering generation function
   static Ordering DefaultOrderingFunc(
       const FactorGraphType& graph,
-      boost::optional<const VariableIndex&> variableIndex) {
-    return Ordering::Colamd(*variableIndex);
+      std::optional<std::reference_wrapper<const VariableIndex>> variableIndex) {
+    return Ordering::Colamd((*variableIndex).get());
   }
 };
 
@@ -155,7 +155,7 @@ class GTSAM_EXPORT DiscreteFactorGraph
    * @return DiscreteBayesNet encoding posterior P(X|Z)
    */
   DiscreteBayesNet sumProduct(
-      OptionalOrderingType orderingType = boost::none) const;
+      OptionalOrderingType orderingType = {}) const;
 
   /**
    * @brief Implement the sum-product algorithm
@@ -172,7 +172,7 @@ class GTSAM_EXPORT DiscreteFactorGraph
    * @return DiscreteLookupDAG DAG with lookup tables
    */
   DiscreteLookupDAG maxProduct(
-      OptionalOrderingType orderingType = boost::none) const;
+      OptionalOrderingType orderingType = {}) const;
 
   /**
    * @brief Implement the max-product algorithm
@@ -189,7 +189,7 @@ class GTSAM_EXPORT DiscreteFactorGraph
    * @return DiscreteValues : MPE
    */
   DiscreteValues optimize(
-      OptionalOrderingType orderingType = boost::none) const;
+      OptionalOrderingType orderingType = {}) const;
 
   /**
    * @brief Find the maximum probable explanation (MPE) by doing max-product.
diff --git a/gtsam/discrete/Signature.cpp b/gtsam/discrete/Signature.cpp
index 146555898..bc045e8c2 100644
--- a/gtsam/discrete/Signature.cpp
+++ b/gtsam/discrete/Signature.cpp
@@ -137,14 +137,14 @@ namespace gtsam {
   }
 
   Signature& Signature::operator=(const string& spec) {
-    spec_.reset(spec);
+    spec_ = spec;
     Table table;
     parser::It f = spec.begin(), l = spec.end();
     bool success =
         qi::phrase_parse(f, l, parser::grammar.table, qi::space, table);
     if (success) {
       for (Row& row : table) normalize(row);
-      table_.reset(table);
+      table_ = table;
     }
     return *this;
   }
@@ -153,7 +153,7 @@ namespace gtsam {
     Table table = t;
     for(Row& row: table)
       normalize(row);
-    table_.reset(table);
+    table_ = table;
     return *this;
   }
 
diff --git a/gtsam/discrete/Signature.h b/gtsam/discrete/Signature.h
index 3138435a9..963843ab2 100644
--- a/gtsam/discrete/Signature.h
+++ b/gtsam/discrete/Signature.h
@@ -19,7 +19,7 @@
 #pragma once
 #include <string>
 #include <vector>
-#include <boost/optional.hpp>
+#include <optional>
 #include <gtsam/discrete/DiscreteKey.h>
 
 namespace gtsam {
@@ -68,10 +68,10 @@ namespace gtsam {
     DiscreteKeys parents_;
 
     // the given CPT specification string
-    boost::optional<std::string> spec_;
+    std::optional<std::string> spec_;
 
     // the CPT as parsed, if successful
-    boost::optional<Table> table_;
+    std::optional<Table> table_;
 
   public:
    /**
@@ -124,7 +124,7 @@ namespace gtsam {
    KeyVector indices() const;
 
    // the CPT as parsed, if successful
-   const boost::optional<Table>& table() const { return table_; }
+   const std::optional<Table>& table() const { return table_; }
 
    // the CPT as a vector of doubles, with key's values most rapidly changing
    std::vector<double> cpt() const;
diff --git a/gtsam/geometry/BearingRange.h b/gtsam/geometry/BearingRange.h
index 95b0232f0..ca767c1f1 100644
--- a/gtsam/geometry/BearingRange.h
+++ b/gtsam/geometry/BearingRange.h
@@ -77,8 +77,8 @@ public:
   /// Prediction function that stacks measurements
   static BearingRange Measure(
     const A1& a1, const A2& a2,
-    OptionalJacobian<dimension, traits<A1>::dimension> H1 = boost::none,
-    OptionalJacobian<dimension, traits<A2>::dimension> H2 = boost::none) {
+    OptionalJacobian<dimension, traits<A1>::dimension> H1 = {},
+    OptionalJacobian<dimension, traits<A2>::dimension> H2 = {}) {
     typename MakeJacobian<B, A1>::type HB1;
     typename MakeJacobian<B, A2>::type HB2;
     typename MakeJacobian<R, A1>::type HR1;
@@ -181,8 +181,8 @@ struct HasBearing {
   typedef RT result_type;
   RT operator()(
       const A1& a1, const A2& a2,
-      OptionalJacobian<traits<RT>::dimension, traits<A1>::dimension> H1=boost::none,
-      OptionalJacobian<traits<RT>::dimension, traits<A2>::dimension> H2=boost::none) {
+      OptionalJacobian<traits<RT>::dimension, traits<A1>::dimension> H1={},
+      OptionalJacobian<traits<RT>::dimension, traits<A2>::dimension> H2={}) {
     return a1.bearing(a2, H1, H2);
   }
 };
@@ -195,8 +195,8 @@ struct HasRange {
   typedef RT result_type;
   RT operator()(
       const A1& a1, const A2& a2,
-      OptionalJacobian<traits<RT>::dimension, traits<A1>::dimension> H1=boost::none,
-      OptionalJacobian<traits<RT>::dimension, traits<A2>::dimension> H2=boost::none) {
+      OptionalJacobian<traits<RT>::dimension, traits<A1>::dimension> H1={},
+      OptionalJacobian<traits<RT>::dimension, traits<A2>::dimension> H2={}) {
     return a1.range(a2, H1, H2);
   }
 };
diff --git a/gtsam/geometry/Cal3.h b/gtsam/geometry/Cal3.h
index e3cf8f79c..eb7d1ff27 100644
--- a/gtsam/geometry/Cal3.h
+++ b/gtsam/geometry/Cal3.h
@@ -45,8 +45,8 @@ namespace gtsam {
  */
 template <typename Cal, size_t Dim>
 void calibrateJacobians(const Cal& calibration, const Point2& pn,
-                        OptionalJacobian<2, Dim> Dcal = boost::none,
-                        OptionalJacobian<2, 2> Dp = boost::none) {
+                        OptionalJacobian<2, Dim> Dcal = {},
+                        OptionalJacobian<2, 2> Dp = {}) {
   if (Dcal || Dp) {
     Eigen::Matrix<double, 2, Dim> H_uncal_K;
     Matrix22 H_uncal_pn, H_uncal_pn_inv;
diff --git a/gtsam/geometry/Cal3Bundler.cpp b/gtsam/geometry/Cal3Bundler.cpp
index 3ae624bbc..cfaea61a9 100644
--- a/gtsam/geometry/Cal3Bundler.cpp
+++ b/gtsam/geometry/Cal3Bundler.cpp
@@ -131,14 +131,14 @@ Point2 Cal3Bundler::calibrate(const Point2& pi, OptionalJacobian<2, 3> Dcal,
 /* ************************************************************************* */
 Matrix2 Cal3Bundler::D2d_intrinsic(const Point2& p) const {
   Matrix2 Dp;
-  uncalibrate(p, boost::none, Dp);
+  uncalibrate(p, {}, Dp);
   return Dp;
 }
 
 /* ************************************************************************* */
 Matrix23 Cal3Bundler::D2d_calibration(const Point2& p) const {
   Matrix23 Dcal;
-  uncalibrate(p, Dcal, boost::none);
+  uncalibrate(p, Dcal, {});
   return Dcal;
 }
 
diff --git a/gtsam/geometry/Cal3Bundler.h b/gtsam/geometry/Cal3Bundler.h
index 46dae5f9b..2a32f6297 100644
--- a/gtsam/geometry/Cal3Bundler.h
+++ b/gtsam/geometry/Cal3Bundler.h
@@ -108,8 +108,8 @@ class GTSAM_EXPORT Cal3Bundler : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in image coordinates
    */
-  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 3> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 3> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert a pixel coordinate to ideal coordinate xy
@@ -119,8 +119,8 @@ class GTSAM_EXPORT Cal3Bundler : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in intrinsic coordinates
    */
-  Point2 calibrate(const Point2& pi, OptionalJacobian<2, 3> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& pi, OptionalJacobian<2, 3> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /// @deprecated might be removed in next release, use uncalibrate
   Matrix2 D2d_intrinsic(const Point2& p) const;
diff --git a/gtsam/geometry/Cal3DS2_Base.h b/gtsam/geometry/Cal3DS2_Base.h
index f901de9a9..c8c76dcb9 100644
--- a/gtsam/geometry/Cal3DS2_Base.h
+++ b/gtsam/geometry/Cal3DS2_Base.h
@@ -122,12 +122,12 @@ class GTSAM_EXPORT Cal3DS2_Base : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in (distorted) image coordinates
    */
-  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /// Convert (distorted) image coordinates uv to intrinsic coordinates xy
-  Point2 calibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /// Derivative of uncalibrate wrpt intrinsic coordinates
   Matrix2 D2d_intrinsic(const Point2& p) const;
diff --git a/gtsam/geometry/Cal3Fisheye.cpp b/gtsam/geometry/Cal3Fisheye.cpp
index fd2c7ab65..fac09e465 100644
--- a/gtsam/geometry/Cal3Fisheye.cpp
+++ b/gtsam/geometry/Cal3Fisheye.cpp
@@ -134,7 +134,7 @@ Point2 Cal3Fisheye::calibrate(const Point2& uv, OptionalJacobian<2, 9> Dcal,
     Matrix2 jac;
 
     // Calculate the current estimate (uv_hat) and the jacobian
-    const Point2 uv_hat = uncalibrate(pi, boost::none, jac);
+    const Point2 uv_hat = uncalibrate(pi, {}, jac);
 
     // Test convergence
     if ((uv_hat - uv).norm() < tol_) break;
diff --git a/gtsam/geometry/Cal3Fisheye.h b/gtsam/geometry/Cal3Fisheye.h
index a314acb5e..2530231c5 100644
--- a/gtsam/geometry/Cal3Fisheye.h
+++ b/gtsam/geometry/Cal3Fisheye.h
@@ -121,8 +121,8 @@ class GTSAM_EXPORT Cal3Fisheye : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates (xi, yi)
    * @return point in (distorted) image coordinates
    */
-  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert (distorted) image coordinates [u;v] to intrinsic coordinates [x_i,
@@ -132,8 +132,8 @@ class GTSAM_EXPORT Cal3Fisheye : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates (xi, yi)
    * @return point in intrinsic coordinates
    */
-  Point2 calibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& p, OptionalJacobian<2, 9> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /// @}
   /// @name Testable
diff --git a/gtsam/geometry/Cal3Unified.h b/gtsam/geometry/Cal3Unified.h
index 83024c0ce..cf25c8f00 100644
--- a/gtsam/geometry/Cal3Unified.h
+++ b/gtsam/geometry/Cal3Unified.h
@@ -106,12 +106,12 @@ class GTSAM_EXPORT Cal3Unified : public Cal3DS2_Base {
    * @return point in image coordinates
    */
   Point2 uncalibrate(const Point2& p,
-                     OptionalJacobian<2, 10> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+                     OptionalJacobian<2, 10> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /// Conver a pixel coordinate to ideal coordinate
-  Point2 calibrate(const Point2& p, OptionalJacobian<2, 10> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& p, OptionalJacobian<2, 10> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /// Convert a 3D point to normalized unit plane
   Point2 spaceToNPlane(const Point2& p) const;
diff --git a/gtsam/geometry/Cal3_S2.h b/gtsam/geometry/Cal3_S2.h
index 10061fae8..b8d776538 100644
--- a/gtsam/geometry/Cal3_S2.h
+++ b/gtsam/geometry/Cal3_S2.h
@@ -66,8 +66,8 @@ class GTSAM_EXPORT Cal3_S2 : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in image coordinates
    */
-  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 5> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 5> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert image coordinates uv to intrinsic coordinates xy
@@ -76,8 +76,8 @@ class GTSAM_EXPORT Cal3_S2 : public Cal3 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in intrinsic coordinates
    */
-  Point2 calibrate(const Point2& p, OptionalJacobian<2, 5> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& p, OptionalJacobian<2, 5> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert homogeneous image coordinates to intrinsic coordinates
@@ -102,8 +102,8 @@ class GTSAM_EXPORT Cal3_S2 : public Cal3 {
 
   /// "Between", subtracts calibrations. between(p,q) == compose(inverse(p),q)
   inline Cal3_S2 between(const Cal3_S2& q,
-                         OptionalJacobian<5, 5> H1 = boost::none,
-                         OptionalJacobian<5, 5> H2 = boost::none) const {
+                         OptionalJacobian<5, 5> H1 = {},
+                         OptionalJacobian<5, 5> H2 = {}) const {
     if (H1) *H1 = -I_5x5;
     if (H2) *H2 = I_5x5;
     return Cal3_S2(q.fx_ - fx_, q.fy_ - fy_, q.s_ - s_, q.u0_ - u0_,
diff --git a/gtsam/geometry/Cal3_S2Stereo.h b/gtsam/geometry/Cal3_S2Stereo.h
index ddd96bf17..574b5d7b5 100644
--- a/gtsam/geometry/Cal3_S2Stereo.h
+++ b/gtsam/geometry/Cal3_S2Stereo.h
@@ -64,8 +64,8 @@ class GTSAM_EXPORT Cal3_S2Stereo : public Cal3_S2 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in image coordinates
    */
-  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 6> Dcal = boost::none,
-                     OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 uncalibrate(const Point2& p, OptionalJacobian<2, 6> Dcal = {},
+                     OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert image coordinates uv to intrinsic coordinates xy
@@ -74,8 +74,8 @@ class GTSAM_EXPORT Cal3_S2Stereo : public Cal3_S2 {
    * @param Dp optional 2*2 Jacobian wrpt intrinsic coordinates
    * @return point in intrinsic coordinates
    */
-  Point2 calibrate(const Point2& p, OptionalJacobian<2, 6> Dcal = boost::none,
-                   OptionalJacobian<2, 2> Dp = boost::none) const;
+  Point2 calibrate(const Point2& p, OptionalJacobian<2, 6> Dcal = {},
+                   OptionalJacobian<2, 2> Dp = {}) const;
 
   /**
    * Convert homogeneous image coordinates to intrinsic coordinates
diff --git a/gtsam/geometry/CalibratedCamera.cpp b/gtsam/geometry/CalibratedCamera.cpp
index dd88f9f69..34deb5c84 100644
--- a/gtsam/geometry/CalibratedCamera.cpp
+++ b/gtsam/geometry/CalibratedCamera.cpp
@@ -117,7 +117,7 @@ Point2 PinholeBase::project2(const Point3& point, OptionalJacobian<2, 6> Dpose,
     OptionalJacobian<2, 3> Dpoint) const {
 
   Matrix3 Rt; // calculated by transformTo if needed
-  const Point3 q = pose().transformTo(point, boost::none, Dpoint ? &Rt : 0);
+  const Point3 q = pose().transformTo(point, {}, Dpoint ? &Rt : 0);
 #ifdef GTSAM_THROW_CHEIRALITY_EXCEPTION
   if (q.z() <= 0)
     throw CheiralityException();
diff --git a/gtsam/geometry/CalibratedCamera.h b/gtsam/geometry/CalibratedCamera.h
index 941ed3ffc..c8e27444e 100644
--- a/gtsam/geometry/CalibratedCamera.h
+++ b/gtsam/geometry/CalibratedCamera.h
@@ -176,7 +176,7 @@ public:
    * @param pc point in camera coordinates
    */
   static Point2 Project(const Point3& pc, //
-      OptionalJacobian<2, 3> Dpoint = boost::none);
+      OptionalJacobian<2, 3> Dpoint = {});
 
   /**
    * Project from 3D point at infinity in camera coordinates into image
@@ -184,7 +184,7 @@ public:
    * @param pc point in camera coordinates
    */
   static Point2 Project(const Unit3& pc, //
-      OptionalJacobian<2, 2> Dpoint = boost::none);
+      OptionalJacobian<2, 2> Dpoint = {});
 
   /// Project a point into the image and check depth
   std::pair<Point2, bool> projectSafe(const Point3& pw) const;
@@ -195,7 +195,7 @@ public:
    * @return the intrinsic coordinates of the projected point
    */
   Point2 project2(const Point3& point, OptionalJacobian<2, 6> Dpose =
-      boost::none, OptionalJacobian<2, 3> Dpoint = boost::none) const;
+      {}, OptionalJacobian<2, 3> Dpoint = {}) const;
 
   /** Project point at infinity into the image
    * Throws a CheiralityException if point behind image plane iff GTSAM_THROW_CHEIRALITY_EXCEPTION
@@ -203,13 +203,13 @@ public:
    * @return the intrinsic coordinates of the projected point
    */
   Point2 project2(const Unit3& point,
-      OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 2> Dpoint = boost::none) const;
+      OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 2> Dpoint = {}) const;
 
   /// backproject a 2-dimensional point to a 3-dimensional point at given depth
   static Point3 BackprojectFromCamera(const Point2& p, const double depth,
-                                      OptionalJacobian<3, 2> Dpoint = boost::none,
-                                      OptionalJacobian<3, 1> Ddepth = boost::none);
+                                      OptionalJacobian<3, 2> Dpoint = {},
+                                      OptionalJacobian<3, 1> Ddepth = {});
 
   /// @}
   /// @name Advanced interface
@@ -270,7 +270,7 @@ public:
 
   // Create CalibratedCamera, with derivatives
   static CalibratedCamera Create(const Pose3& pose,
-                                 OptionalJacobian<dimension, 6> H1 = boost::none) {
+                                 OptionalJacobian<dimension, 6> H1 = {}) {
     if (H1)
       *H1 << I_6x6;
     return CalibratedCamera(pose);
@@ -346,13 +346,13 @@ public:
    * Use project2, which is more consistently named across Pinhole cameras
    */
   Point2 project(const Point3& point, OptionalJacobian<2, 6> Dcamera =
-      boost::none, OptionalJacobian<2, 3> Dpoint = boost::none) const;
+      {}, OptionalJacobian<2, 3> Dpoint = {}) const;
 
   /// backproject a 2-dimensional point to a 3-dimensional point at given depth
   Point3 backproject(const Point2& pn, double depth,
-                     OptionalJacobian<3, 6> Dresult_dpose = boost::none,
-                     OptionalJacobian<3, 2> Dresult_dp = boost::none,
-                     OptionalJacobian<3, 1> Dresult_ddepth = boost::none) const {
+                     OptionalJacobian<3, 6> Dresult_dpose = {},
+                     OptionalJacobian<3, 2> Dresult_dp = {},
+                     OptionalJacobian<3, 1> Dresult_ddepth = {}) const {
 
     Matrix32 Dpoint_dpn;
     Matrix31 Dpoint_ddepth;
@@ -379,8 +379,8 @@ public:
    * @return range (double)
    */
   double range(const Point3& point,
-      OptionalJacobian<1, 6> Dcamera = boost::none,
-      OptionalJacobian<1, 3> Dpoint = boost::none) const {
+      OptionalJacobian<1, 6> Dcamera = {},
+      OptionalJacobian<1, 3> Dpoint = {}) const {
     return pose().range(point, Dcamera, Dpoint);
   }
 
@@ -389,8 +389,8 @@ public:
    * @param pose Other SO(3) pose
    * @return range (double)
    */
-  double range(const Pose3& pose, OptionalJacobian<1, 6> Dcamera = boost::none,
-      OptionalJacobian<1, 6> Dpose = boost::none) const {
+  double range(const Pose3& pose, OptionalJacobian<1, 6> Dcamera = {},
+      OptionalJacobian<1, 6> Dpose = {}) const {
     return this->pose().range(pose, Dcamera, Dpose);
   }
 
@@ -400,8 +400,8 @@ public:
    * @return range (double)
    */
   double range(const CalibratedCamera& camera, //
-      OptionalJacobian<1, 6> H1 = boost::none, //
-      OptionalJacobian<1, 6> H2 = boost::none) const {
+      OptionalJacobian<1, 6> H1 = {}, //
+      OptionalJacobian<1, 6> H2 = {}) const {
     return pose().range(camera.pose(), H1, H2);
   }
 
diff --git a/gtsam/geometry/EssentialMatrix.h b/gtsam/geometry/EssentialMatrix.h
index 909576aa0..ea980d667 100644
--- a/gtsam/geometry/EssentialMatrix.h
+++ b/gtsam/geometry/EssentialMatrix.h
@@ -49,12 +49,12 @@ class EssentialMatrix {
 
   /// Named constructor with derivatives
   GTSAM_EXPORT static EssentialMatrix FromRotationAndDirection(const Rot3& aRb, const Unit3& aTb,
-                                                  OptionalJacobian<5, 3> H1 = boost::none,
-                                                  OptionalJacobian<5, 2> H2 = boost::none);
+                                                  OptionalJacobian<5, 3> H1 = {},
+                                                  OptionalJacobian<5, 2> H2 = {});
 
   /// Named constructor converting a Pose3 with scale to EssentialMatrix (no scale)
   GTSAM_EXPORT static EssentialMatrix FromPose3(const Pose3& _1P2_,
-      OptionalJacobian<5, 6> H = boost::none);
+      OptionalJacobian<5, 6> H = {});
 
   /// Random, using Rot3::Random and Unit3::Random
   template<typename Engine>
@@ -139,8 +139,8 @@ class EssentialMatrix {
    * @return point in pose coordinates
    */
   GTSAM_EXPORT Point3 transformTo(const Point3& p,
-      OptionalJacobian<3, 5> DE = boost::none,
-      OptionalJacobian<3, 3> Dpoint = boost::none) const;
+      OptionalJacobian<3, 5> DE = {},
+      OptionalJacobian<3, 3> Dpoint = {}) const;
 
   /**
    * Given essential matrix E in camera frame B, convert to body frame C
@@ -148,7 +148,7 @@ class EssentialMatrix {
    * @param E essential matrix E in camera frame C
    */
   GTSAM_EXPORT EssentialMatrix rotate(const Rot3& cRb, OptionalJacobian<5, 5> HE =
-      boost::none, OptionalJacobian<5, 3> HR = boost::none) const;
+      {}, OptionalJacobian<5, 3> HR = {}) const;
 
   /**
    * Given essential matrix E in camera frame B, convert to body frame C
@@ -161,7 +161,7 @@ class EssentialMatrix {
 
   /// epipolar error, algebraic
   GTSAM_EXPORT double error(const Vector3& vA, const Vector3& vB,
-      OptionalJacobian<1, 5> H = boost::none) const;
+      OptionalJacobian<1, 5> H = {}) const;
 
   /// @}
 
diff --git a/gtsam/geometry/Line3.h b/gtsam/geometry/Line3.h
index 08b81eaef..b1a1e4f6e 100644
--- a/gtsam/geometry/Line3.h
+++ b/gtsam/geometry/Line3.h
@@ -32,8 +32,8 @@ class Line3;
  * @return Transformed line in camera frame
  */
 GTSAM_EXPORT Line3 transformTo(const Pose3 &wTc, const Line3 &wL,
-                  OptionalJacobian<4, 6> Dpose = boost::none,
-                  OptionalJacobian<4, 4> Dline = boost::none);
+                  OptionalJacobian<4, 6> Dpose = {},
+                  OptionalJacobian<4, 4> Dline = {});
 
 
 /**
@@ -69,8 +69,8 @@ class GTSAM_EXPORT Line3 {
    * @return q: resulting line after adding the increment and mapping to the manifold
    */
   Line3 retract(const Vector4 &v,
-                OptionalJacobian<4, 4> Dp = boost::none,
-                OptionalJacobian<4, 4> Dv = boost::none) const;
+                OptionalJacobian<4, 4> Dp = {},
+                OptionalJacobian<4, 4> Dv = {}) const;
 
   /**
    * The localCoordinates method is the inverse of retract and finds the difference
@@ -82,8 +82,8 @@ class GTSAM_EXPORT Line3 {
    * @return v: difference in the tangent space
    */
   Vector4 localCoordinates(const Line3 &q,
-                           OptionalJacobian<4, 4> Dp = boost::none,
-                           OptionalJacobian<4, 4> Dq = boost::none) const;
+                           OptionalJacobian<4, 4> Dp = {},
+                           OptionalJacobian<4, 4> Dq = {}) const;
 
   /**
    * Print R, a, b
@@ -105,7 +105,7 @@ class GTSAM_EXPORT Line3 {
    * @return Unit3 - projected line in image plane, in homogenous coordinates.
    * We use Unit3 since it is a manifold with the right dimension.
    */
-  Unit3 project(OptionalJacobian<2, 4> Dline = boost::none) const;
+  Unit3 project(OptionalJacobian<2, 4> Dline = {}) const;
 
   /**
    * Returns point on the line that is at a certain distance starting from the
diff --git a/gtsam/geometry/OrientedPlane3.h b/gtsam/geometry/OrientedPlane3.h
index d0d912ee9..07c8445fe 100644
--- a/gtsam/geometry/OrientedPlane3.h
+++ b/gtsam/geometry/OrientedPlane3.h
@@ -87,8 +87,8 @@ public:
    * @return the transformed plane
    */
   OrientedPlane3 transform(const Pose3& xr,
-                           OptionalJacobian<3, 3> Hp = boost::none,
-                           OptionalJacobian<3, 6> Hr = boost::none) const;
+                           OptionalJacobian<3, 3> Hp = {},
+                           OptionalJacobian<3, 6> Hr = {}) const;
 
   /** Computes the error between the two planes, with derivatives.
    *  This uses Unit3::errorVector, as opposed to the other .error() in this
@@ -98,8 +98,8 @@ public:
    * @param other the other plane
    */
   Vector3 errorVector(const OrientedPlane3& other,
-                      OptionalJacobian<3, 3> H1 = boost::none,
-                      OptionalJacobian<3, 3> H2 = boost::none) const;
+                      OptionalJacobian<3, 3> H1 = {},
+                      OptionalJacobian<3, 3> H2 = {}) const;
 
   /// Dimensionality of tangent space = 3 DOF
   inline static size_t Dim() {
@@ -113,7 +113,7 @@ public:
 
   /// The retract function
   OrientedPlane3 retract(const Vector3& v,
-                        OptionalJacobian<3, 3> H = boost::none) const;
+                        OptionalJacobian<3, 3> H = {}) const;
 
   /// The local coordinates function
   Vector3 localCoordinates(const OrientedPlane3& s) const;
@@ -125,13 +125,13 @@ public:
   }
 
   /// Return the normal
-  inline Unit3 normal(OptionalJacobian<2, 3> H = boost::none) const {
+  inline Unit3 normal(OptionalJacobian<2, 3> H = {}) const {
     if (H) *H << I_2x2, Z_2x1;
     return n_;
   }
 
   /// Return the perpendicular distance to the origin
-  inline double distance(OptionalJacobian<1, 3> H = boost::none) const {
+  inline double distance(OptionalJacobian<1, 3> H = {}) const {
     if (H) *H << 0,0,1;
     return d_;
   }
diff --git a/gtsam/geometry/PinholeCamera.h b/gtsam/geometry/PinholeCamera.h
index 48233c1ed..8f299f854 100644
--- a/gtsam/geometry/PinholeCamera.h
+++ b/gtsam/geometry/PinholeCamera.h
@@ -109,8 +109,8 @@ public:
 
   // Create PinholeCamera, with derivatives
   static PinholeCamera Create(const Pose3& pose, const Calibration &K,
-      OptionalJacobian<dimension, 6> H1 = boost::none, //
-      OptionalJacobian<dimension, DimK> H2 = boost::none) {
+      OptionalJacobian<dimension, 6> H1 = {}, //
+      OptionalJacobian<dimension, DimK> H2 = {}) {
     typedef Eigen::Matrix<double, DimK, 6> MatrixK6;
     if (H1)
       *H1 << I_6x6, MatrixK6::Zero();
@@ -237,19 +237,19 @@ public:
       *Dcamera << Dpose, Dcal;
       return pi;
     } else {
-      return Base::project(pw, boost::none, Dpoint, boost::none);
+      return Base::project(pw, {}, Dpoint, {});
     }
   }
 
   /// project a 3D point from world coordinates into the image
   Point2 project2(const Point3& pw, OptionalJacobian<2, dimension> Dcamera =
-      boost::none, OptionalJacobian<2, 3> Dpoint = boost::none) const {
+      {}, OptionalJacobian<2, 3> Dpoint = {}) const {
     return _project2(pw, Dcamera, Dpoint);
   }
 
   /// project a point at infinity from world coordinates into the image
   Point2 project2(const Unit3& pw, OptionalJacobian<2, dimension> Dcamera =
-      boost::none, OptionalJacobian<2, 2> Dpoint = boost::none) const {
+      {}, OptionalJacobian<2, 2> Dpoint = {}) const {
     return _project2(pw, Dcamera, Dpoint);
   }
 
@@ -259,7 +259,7 @@ public:
    * @return range (double)
    */
   double range(const Point3& point, OptionalJacobian<1, dimension> Dcamera =
-      boost::none, OptionalJacobian<1, 3> Dpoint = boost::none) const {
+      {}, OptionalJacobian<1, 3> Dpoint = {}) const {
     Matrix16 Dpose_;
     double result = this->pose().range(point, Dcamera ? &Dpose_ : 0, Dpoint);
     if (Dcamera)
@@ -273,7 +273,7 @@ public:
    * @return range (double)
    */
   double range(const Pose3& pose, OptionalJacobian<1, dimension> Dcamera =
-      boost::none, OptionalJacobian<1, 6> Dpose = boost::none) const {
+      {}, OptionalJacobian<1, 6> Dpose = {}) const {
     Matrix16 Dpose_;
     double result = this->pose().range(pose, Dcamera ? &Dpose_ : 0, Dpose);
     if (Dcamera)
@@ -288,8 +288,8 @@ public:
    */
   template<class CalibrationB>
   double range(const PinholeCamera<CalibrationB>& camera,
-      OptionalJacobian<1, dimension> Dcamera = boost::none,
-      OptionalJacobian<1, 6 + CalibrationB::dimension> Dother = boost::none) const {
+      OptionalJacobian<1, dimension> Dcamera = {},
+      OptionalJacobian<1, 6 + CalibrationB::dimension> Dother = {}) const {
     Matrix16 Dcamera_, Dother_;
     double result = this->pose().range(camera.pose(), Dcamera ? &Dcamera_ : 0,
         Dother ? &Dother_ : 0);
@@ -309,8 +309,8 @@ public:
    * @return range (double)
    */
   double range(const CalibratedCamera& camera,
-      OptionalJacobian<1, dimension> Dcamera = boost::none,
-      OptionalJacobian<1, 6> Dother = boost::none) const {
+      OptionalJacobian<1, dimension> Dcamera = {},
+      OptionalJacobian<1, 6> Dother = {}) const {
     return range(camera.pose(), Dcamera, Dother);
   }
 
diff --git a/gtsam/geometry/PinholePose.h b/gtsam/geometry/PinholePose.h
index b2de4fb11..e9d3859a1 100644
--- a/gtsam/geometry/PinholePose.h
+++ b/gtsam/geometry/PinholePose.h
@@ -115,32 +115,32 @@ public:
   }
 
   /// project a 3D point from world coordinates into the image
-  Point2 project(const Point3& pw, OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 3> Dpoint = boost::none,
-      OptionalJacobian<2, DimK> Dcal = boost::none) const {
+  Point2 project(const Point3& pw, OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 3> Dpoint = {},
+      OptionalJacobian<2, DimK> Dcal = {}) const {
     return _project(pw, Dpose, Dpoint, Dcal);
   }
 
   /// project a 3D point from world coordinates into the image
-  Point2 reprojectionError(const Point3& pw, const Point2& measured, OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 3> Dpoint = boost::none,
-      OptionalJacobian<2, DimK> Dcal = boost::none) const {
+  Point2 reprojectionError(const Point3& pw, const Point2& measured, OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 3> Dpoint = {},
+      OptionalJacobian<2, DimK> Dcal = {}) const {
     return Point2(_project(pw, Dpose, Dpoint, Dcal) - measured);
   }
 
   /// project a point at infinity from world coordinates into the image
-  Point2 project(const Unit3& pw, OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 2> Dpoint = boost::none,
-      OptionalJacobian<2, DimK> Dcal = boost::none) const {
+  Point2 project(const Unit3& pw, OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 2> Dpoint = {},
+      OptionalJacobian<2, DimK> Dcal = {}) const {
     return _project(pw, Dpose, Dpoint, Dcal);
   }
 
   /// backproject a 2-dimensional point to a 3-dimensional point at given depth
   Point3 backproject(const Point2& p, double depth,
-                     OptionalJacobian<3, 6> Dresult_dpose = boost::none,
-                     OptionalJacobian<3, 2> Dresult_dp = boost::none,
-                     OptionalJacobian<3, 1> Dresult_ddepth = boost::none,
-                     OptionalJacobian<3, DimK> Dresult_dcal = boost::none) const {
+                     OptionalJacobian<3, 6> Dresult_dpose = {},
+                     OptionalJacobian<3, 2> Dresult_dp = {},
+                     OptionalJacobian<3, 1> Dresult_ddepth = {},
+                     OptionalJacobian<3, DimK> Dresult_dcal = {}) const {
     typedef Eigen::Matrix<double, 2, DimK> Matrix2K;
     Matrix2K Dpn_dcal;
     Matrix22 Dpn_dp;
@@ -179,8 +179,8 @@ public:
    * @return range (double)
    */
   double range(const Point3& point,
-      OptionalJacobian<1, 6> Dcamera = boost::none,
-      OptionalJacobian<1, 3> Dpoint = boost::none) const {
+      OptionalJacobian<1, 6> Dcamera = {},
+      OptionalJacobian<1, 3> Dpoint = {}) const {
     return pose().range(point, Dcamera, Dpoint);
   }
 
@@ -189,8 +189,8 @@ public:
    * @param pose Other SO(3) pose
    * @return range (double)
    */
-  double range(const Pose3& pose, OptionalJacobian<1, 6> Dcamera = boost::none,
-      OptionalJacobian<1, 6> Dpose = boost::none) const {
+  double range(const Pose3& pose, OptionalJacobian<1, 6> Dcamera = {},
+      OptionalJacobian<1, 6> Dpose = {}) const {
     return this->pose().range(pose, Dcamera, Dpose);
   }
 
@@ -200,7 +200,7 @@ public:
    * @return range (double)
    */
   double range(const CalibratedCamera& camera, OptionalJacobian<1, 6> Dcamera =
-      boost::none, OptionalJacobian<1, 6> Dother = boost::none) const {
+      {}, OptionalJacobian<1, 6> Dother = {}) const {
     return pose().range(camera.pose(), Dcamera, Dother);
   }
 
@@ -211,8 +211,8 @@ public:
    */
   template<class CalibrationB>
   double range(const PinholeBaseK<CalibrationB>& camera,
-      OptionalJacobian<1, 6> Dcamera = boost::none,
-      OptionalJacobian<1, 6> Dother = boost::none) const {
+      OptionalJacobian<1, 6> Dcamera = {},
+      OptionalJacobian<1, 6> Dother = {}) const {
     return pose().range(camera.pose(), Dcamera, Dother);
   }
 
@@ -376,14 +376,14 @@ public:
    *  @param Dpose is the Jacobian w.r.t. the whole camera (really only the pose)
    *  @param Dpoint is the Jacobian w.r.t. point3
    */
-  Point2 project2(const Point3& pw, OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 3> Dpoint = boost::none) const {
+  Point2 project2(const Point3& pw, OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 3> Dpoint = {}) const {
     return Base::project(pw, Dpose, Dpoint);
   }
 
   /// project2 version for point at infinity
-  Point2 project2(const Unit3& pw, OptionalJacobian<2, 6> Dpose = boost::none,
-      OptionalJacobian<2, 2> Dpoint = boost::none) const {
+  Point2 project2(const Unit3& pw, OptionalJacobian<2, 6> Dpose = {},
+      OptionalJacobian<2, 2> Dpoint = {}) const {
     return Base::project(pw, Dpose, Dpoint);
   }
 
diff --git a/gtsam/geometry/PinholeSet.h b/gtsam/geometry/PinholeSet.h
index 7e3dae56f..7541f886b 100644
--- a/gtsam/geometry/PinholeSet.h
+++ b/gtsam/geometry/PinholeSet.h
@@ -19,7 +19,6 @@
 
 #include <gtsam/geometry/CameraSet.h>
 #include <gtsam/geometry/triangulation.h>
-#include <boost/optional.hpp>
 
 namespace gtsam {
 
diff --git a/gtsam/geometry/Point2.cpp b/gtsam/geometry/Point2.cpp
index 06c32526b..54c94addb 100644
--- a/gtsam/geometry/Point2.cpp
+++ b/gtsam/geometry/Point2.cpp
@@ -52,7 +52,7 @@ double distance2(const Point2& p, const Point2& q, OptionalJacobian<1, 2> H1,
 
 /* ************************************************************************* */
 // Math inspired by http://paulbourke.net/geometry/circlesphere/
-boost::optional<Point2> circleCircleIntersection(double R_d, double r_d,
+std::optional<Point2> circleCircleIntersection(double R_d, double r_d,
     double tol) {
 
   double R2_d2 = R_d*R_d; // Yes, RD-D2 !
@@ -61,17 +61,17 @@ boost::optional<Point2> circleCircleIntersection(double R_d, double r_d,
 
   // h^2<0 is equivalent to (d > (R + r) || d < (R - r))
   // Hence, there are only solutions if >=0
-  if (h2<-tol) return boost::none; // allow *slightly* negative
+  if (h2<-tol) return {}; // allow *slightly* negative
   else if (h2<tol) return Point2(f,0.0); // one solution
   else return Point2(f,std::sqrt(h2)); // two solutions
 }
 
 /* ************************************************************************* */
 list<Point2> circleCircleIntersection(Point2 c1, Point2 c2,
-    boost::optional<Point2> fh) {
+    std::optional<Point2> fh) {
 
   list<Point2> solutions;
-  // If fh==boost::none, there are no solutions, i.e., d > (R + r) || d < (R - r)
+  // If fh==std::nullopt, there are no solutions, i.e., d > (R + r) || d < (R - r)
   if (fh) {
     // vector between circle centers
     Point2 c12 = c2-c1;
@@ -107,7 +107,7 @@ list<Point2> circleCircleIntersection(Point2 c1, double r1, Point2 c2,
 
   // Calculate f and h given normalized radii
   double _d = 1.0/d, R_d = r1*_d, r_d=r2*_d;
-  boost::optional<Point2> fh = circleCircleIntersection(R_d,r_d);
+  std::optional<Point2> fh = circleCircleIntersection(R_d,r_d);
 
   // Call version that takes fh
   return circleCircleIntersection(c1, c2, fh);
diff --git a/gtsam/geometry/Point2.h b/gtsam/geometry/Point2.h
index d8b6daca8..6d5940584 100644
--- a/gtsam/geometry/Point2.h
+++ b/gtsam/geometry/Point2.h
@@ -18,8 +18,11 @@
 #pragma once
 
 #include <gtsam/base/VectorSpace.h>
+#include <gtsam/base/std_optional_serialization.h>
 #include <boost/serialization/nvp.hpp>
 
+#include <optional>
+
 namespace gtsam {
 
 /// As of GTSAM 4, in order to make GTSAM more lean,
@@ -33,12 +36,12 @@ GTSAM_EXPORT std::ostream &operator<<(std::ostream &os, const gtsam::Point2Pair
 using Point2Pairs = std::vector<Point2Pair>;
 
 /// Distance of the point from the origin, with Jacobian
-GTSAM_EXPORT double norm2(const Point2& p, OptionalJacobian<1, 2> H = boost::none);
+GTSAM_EXPORT double norm2(const Point2& p, OptionalJacobian<1, 2> H = {});
 
 /// distance between two points
 GTSAM_EXPORT double distance2(const Point2& p1, const Point2& q,
-                 OptionalJacobian<1, 2> H1 = boost::none,
-                 OptionalJacobian<1, 2> H2 = boost::none);
+                 OptionalJacobian<1, 2> H1 = {},
+                 OptionalJacobian<1, 2> H2 = {});
 
 // For MATLAB wrapper
 typedef std::vector<Point2, Eigen::aligned_allocator<Point2> > Point2Vector;
@@ -53,16 +56,16 @@ inline Point2 operator*(double s, const Point2& p) {
  * Calculate f and h, respectively the parallel and perpendicular distance of
  * the intersections of two circles along and from the line connecting the centers.
  * Both are dimensionless fractions of the distance d between the circle centers.
- * If the circles do not intersect or they are identical, returns boost::none.
+ * If the circles do not intersect or they are identical, returns {}.
  * If one solution (touching circles, as determined by tol), h will be exactly zero.
  * h is a good measure for how accurate the intersection will be, as when circles touch
  * or nearly touch, the intersection is ill-defined with noisy radius measurements.
  * @param R_d : R/d, ratio of radius of first circle to distance between centers
  * @param r_d : r/d, ratio of radius of second circle to distance between centers
  * @param tol: absolute tolerance below which we consider touching circles
- * @return optional Point2 with f and h, boost::none if no solution.
+ * @return optional Point2 with f and h, {} if no solution.
  */
-GTSAM_EXPORT boost::optional<Point2> circleCircleIntersection(double R_d, double r_d, double tol = 1e-9);
+GTSAM_EXPORT std::optional<Point2> circleCircleIntersection(double R_d, double r_d, double tol = 1e-9);
 
 /*
  * @brief Circle-circle intersection, from the normalized radii solution.
@@ -70,7 +73,7 @@ GTSAM_EXPORT boost::optional<Point2> circleCircleIntersection(double R_d, double
  * @param c2 center of second circle
  * @return list of solutions (0,1, or 2). Identical circles will return empty list, as well.
  */
-GTSAM_EXPORT std::list<Point2> circleCircleIntersection(Point2 c1, Point2 c2, boost::optional<Point2> fh);
+GTSAM_EXPORT std::list<Point2> circleCircleIntersection(Point2 c1, Point2 c2, std::optional<Point2> fh);
   
 /// Calculate the two means of a set of Point2 pairs
 GTSAM_EXPORT Point2Pair means(const std::vector<Point2Pair> &abPointPairs);
@@ -94,8 +97,8 @@ template <>
 struct Range<Point2, Point2> {
   typedef double result_type;
   double operator()(const Point2& p, const Point2& q,
-                    OptionalJacobian<1, 2> H1 = boost::none,
-                    OptionalJacobian<1, 2> H2 = boost::none) {
+                    OptionalJacobian<1, 2> H1 = {},
+                    OptionalJacobian<1, 2> H2 = {}) {
     return distance2(p, q, H1, H2);
   }
 };
diff --git a/gtsam/geometry/Point3.h b/gtsam/geometry/Point3.h
index 13a435c24..b1fd26bb2 100644
--- a/gtsam/geometry/Point3.h
+++ b/gtsam/geometry/Point3.h
@@ -44,24 +44,24 @@ using Point3Pairs = std::vector<Point3Pair>;
 
 /// distance between two points
 GTSAM_EXPORT double distance3(const Point3& p1, const Point3& q,
-	                          OptionalJacobian<1, 3> H1 = boost::none,
-                              OptionalJacobian<1, 3> H2 = boost::none);
+	                          OptionalJacobian<1, 3> H1 = {},
+                              OptionalJacobian<1, 3> H2 = {});
 
 /// Distance of the point from the origin, with Jacobian
-GTSAM_EXPORT double norm3(const Point3& p, OptionalJacobian<1, 3> H = boost::none);
+GTSAM_EXPORT double norm3(const Point3& p, OptionalJacobian<1, 3> H = {});
 
 /// normalize, with optional Jacobian
-GTSAM_EXPORT Point3 normalize(const Point3& p, OptionalJacobian<3, 3> H = boost::none);
+GTSAM_EXPORT Point3 normalize(const Point3& p, OptionalJacobian<3, 3> H = {});
 
 /// cross product @return this x q
 GTSAM_EXPORT Point3 cross(const Point3& p, const Point3& q,
-                          OptionalJacobian<3, 3> H_p = boost::none,
-                          OptionalJacobian<3, 3> H_q = boost::none);
+                          OptionalJacobian<3, 3> H_p = {},
+                          OptionalJacobian<3, 3> H_q = {});
 
 /// dot product
 GTSAM_EXPORT double dot(const Point3& p, const Point3& q,
-                        OptionalJacobian<1, 3> H_p = boost::none,
-                        OptionalJacobian<1, 3> H_q = boost::none);
+                        OptionalJacobian<1, 3> H_p = {},
+                        OptionalJacobian<1, 3> H_q = {});
 
 /// mean
 template <class CONTAINER>
@@ -82,8 +82,8 @@ template <>
 struct Range<Point3, Point3> {
   typedef double result_type;
   double operator()(const Point3& p, const Point3& q,
-                    OptionalJacobian<1, 3> H1 = boost::none,
-                    OptionalJacobian<1, 3> H2 = boost::none) {
+                    OptionalJacobian<1, 3> H1 = {},
+                    OptionalJacobian<1, 3> H2 = {}) {
     return distance3(p, q, H1, H2);
   }
 };
diff --git a/gtsam/geometry/Pose2.cpp b/gtsam/geometry/Pose2.cpp
index 47f50cf7e..0d9f1bc01 100644
--- a/gtsam/geometry/Pose2.cpp
+++ b/gtsam/geometry/Pose2.cpp
@@ -327,10 +327,10 @@ double Pose2::range(const Pose2& pose,
  * as they also satisfy ca = t + R*cb, hence t = ca - R*cb
  */
 
-boost::optional<Pose2> Pose2::Align(const Point2Pairs &ab_pairs) {
+std::optional<Pose2> Pose2::Align(const Point2Pairs &ab_pairs) {
   const size_t n = ab_pairs.size();
   if (n < 2) {
-    return boost::none;  // we need at least 2 pairs
+    return {};  // we need at least 2 pairs
   }
 
   // calculate centroids
@@ -359,7 +359,7 @@ boost::optional<Pose2> Pose2::Align(const Point2Pairs &ab_pairs) {
   return Pose2(R, t);
 }
 
-boost::optional<Pose2> Pose2::Align(const Matrix& a, const Matrix& b) {
+std::optional<Pose2> Pose2::Align(const Matrix& a, const Matrix& b) {
   if (a.rows() != 2 || b.rows() != 2 || a.cols() != b.cols()) {
     throw std::invalid_argument(
       "Pose2:Align expects 2*N matrices of equal shape.");
diff --git a/gtsam/geometry/Pose2.h b/gtsam/geometry/Pose2.h
index dc2f87b9f..c106cb4d4 100644
--- a/gtsam/geometry/Pose2.h
+++ b/gtsam/geometry/Pose2.h
@@ -25,6 +25,9 @@
 #include <gtsam/geometry/Rot2.h>
 #include <gtsam/base/Lie.h>
 #include <gtsam/dllexport.h>
+#include <gtsam/base/std_optional_serialization.h>
+
+#include <optional>
 
 namespace gtsam {
 
@@ -99,10 +102,10 @@ public:
    *  Note this allows for noise on the points but in that case the mapping 
    *  will not be exact.
    */
-  static boost::optional<Pose2> Align(const Point2Pairs& abPointPairs);
+  static std::optional<Pose2> Align(const Point2Pairs& abPointPairs);
 
   // Version of Pose2::Align that takes 2 matrices.
-  static boost::optional<Pose2> Align(const Matrix& a, const Matrix& b);
+  static std::optional<Pose2> Align(const Matrix& a, const Matrix& b);
 
   /// @}
   /// @name Testable
@@ -134,10 +137,10 @@ public:
   /// @{
 
   ///Exponential map at identity - create a rotation from canonical coordinates \f$ [T_x,T_y,\theta] \f$
-  GTSAM_EXPORT static Pose2 Expmap(const Vector3& xi, ChartJacobian H = boost::none);
+  GTSAM_EXPORT static Pose2 Expmap(const Vector3& xi, ChartJacobian H = {});
 
   ///Log map at identity - return the canonical coordinates \f$ [T_x,T_y,\theta] \f$ of this rotation
-  GTSAM_EXPORT static Vector3 Logmap(const Pose2& p, ChartJacobian H = boost::none);
+  GTSAM_EXPORT static Vector3 Logmap(const Pose2& p, ChartJacobian H = {});
 
   /**
    * Calculate Adjoint map
@@ -196,8 +199,8 @@ public:
 
   // Chart at origin, depends on compile-time flag SLOW_BUT_CORRECT_EXPMAP
   struct ChartAtOrigin {
-	GTSAM_EXPORT static Pose2 Retract(const Vector3& v, ChartJacobian H = boost::none);
-	GTSAM_EXPORT static Vector3 Local(const Pose2& r, ChartJacobian H = boost::none);
+	GTSAM_EXPORT static Pose2 Retract(const Vector3& v, ChartJacobian H = {});
+	GTSAM_EXPORT static Vector3 Local(const Pose2& r, ChartJacobian H = {});
   };
 
   using LieGroup<Pose2, 3>::inverse; // version with derivative
@@ -208,8 +211,8 @@ public:
 
   /** Return point coordinates in pose coordinate frame */
   GTSAM_EXPORT Point2 transformTo(const Point2& point,
-      OptionalJacobian<2, 3> Dpose = boost::none,
-      OptionalJacobian<2, 2> Dpoint = boost::none) const;
+      OptionalJacobian<2, 3> Dpose = {},
+      OptionalJacobian<2, 2> Dpoint = {}) const;
 
   /**
    * @brief transform many points in world coordinates and transform to Pose.
@@ -220,8 +223,8 @@ public:
 
   /** Return point coordinates in global frame */
   GTSAM_EXPORT Point2 transformFrom(const Point2& point,
-      OptionalJacobian<2, 3> Dpose = boost::none,
-      OptionalJacobian<2, 2> Dpoint = boost::none) const;
+      OptionalJacobian<2, 3> Dpose = {},
+      OptionalJacobian<2, 2> Dpoint = {}) const;
 
   /**
    * @brief transform many points in Pose coordinates and transform to world.
@@ -269,7 +272,7 @@ public:
    * @return 2D rotation \f$ \in SO(2) \f$
    */
   GTSAM_EXPORT Rot2 bearing(const Point2& point,
-               OptionalJacobian<1, 3> H1=boost::none, OptionalJacobian<1, 2> H2=boost::none) const;
+               OptionalJacobian<1, 3> H1={}, OptionalJacobian<1, 2> H2={}) const;
 
   /**
    * Calculate bearing to another pose
@@ -277,7 +280,7 @@ public:
    * @return 2D rotation \f$ \in SO(2) \f$
    */
   GTSAM_EXPORT Rot2 bearing(const Pose2& pose,
-               OptionalJacobian<1, 3> H1=boost::none, OptionalJacobian<1, 3> H2=boost::none) const;
+               OptionalJacobian<1, 3> H1={}, OptionalJacobian<1, 3> H2={}) const;
 
   /**
    * Calculate range to a landmark
@@ -285,8 +288,8 @@ public:
    * @return range (double)
    */
   GTSAM_EXPORT double range(const Point2& point,
-      OptionalJacobian<1, 3> H1=boost::none,
-      OptionalJacobian<1, 2> H2=boost::none) const;
+      OptionalJacobian<1, 3> H1={},
+      OptionalJacobian<1, 2> H2={}) const;
 
   /**
    * Calculate range to another pose
@@ -294,8 +297,8 @@ public:
    * @return range (double)
    */
   GTSAM_EXPORT double range(const Pose2& point,
-      OptionalJacobian<1, 3> H1=boost::none,
-      OptionalJacobian<1, 3> H2=boost::none) const;
+      OptionalJacobian<1, 3> H1={},
+      OptionalJacobian<1, 3> H2={}) const;
 
   /// @}
   /// @name Advanced Interface
diff --git a/gtsam/geometry/Pose3.cpp b/gtsam/geometry/Pose3.cpp
index b018bb8cc..aed055300 100644
--- a/gtsam/geometry/Pose3.cpp
+++ b/gtsam/geometry/Pose3.cpp
@@ -439,14 +439,14 @@ Unit3 Pose3::bearing(const Pose3& pose, OptionalJacobian<2, 6> Hself,
     Hpose->setZero();
     return bearing(pose.translation(), Hself, Hpose.cols<3>(3));
   }
-  return bearing(pose.translation(), Hself, boost::none);
+  return bearing(pose.translation(), Hself, {});
 }
 
 /* ************************************************************************* */
-boost::optional<Pose3> Pose3::Align(const Point3Pairs &abPointPairs) {
+std::optional<Pose3> Pose3::Align(const Point3Pairs &abPointPairs) {
   const size_t n = abPointPairs.size();
   if (n < 3) {
-    return boost::none;  // we need at least three pairs
+    return {};  // we need at least three pairs
   }
 
   // calculate centroids
@@ -466,7 +466,7 @@ boost::optional<Pose3> Pose3::Align(const Point3Pairs &abPointPairs) {
   return Pose3(aRb, aTb);
 }
 
-boost::optional<Pose3> Pose3::Align(const Matrix& a, const Matrix& b) {
+std::optional<Pose3> Pose3::Align(const Matrix& a, const Matrix& b) {
   if (a.rows() != 3 || b.rows() != 3 || a.cols() != b.cols()) {
     throw std::invalid_argument(
       "Pose3:Align expects 3*N matrices of equal shape.");
diff --git a/gtsam/geometry/Pose3.h b/gtsam/geometry/Pose3.h
index 80741e1c3..3dd9e6b9f 100644
--- a/gtsam/geometry/Pose3.h
+++ b/gtsam/geometry/Pose3.h
@@ -75,18 +75,18 @@ public:
 
   /// Named constructor with derivatives
   static Pose3 Create(const Rot3& R, const Point3& t,
-                      OptionalJacobian<6, 3> HR = boost::none,
-                      OptionalJacobian<6, 3> Ht = boost::none);
+                      OptionalJacobian<6, 3> HR = {},
+                      OptionalJacobian<6, 3> Ht = {});
 
   /**
    *  Create Pose3 by aligning two point pairs
    *  A pose aTb is estimated between pairs (a_point, b_point) such that a_point = aTb * b_point
    *  Note this allows for noise on the points but in that case the mapping will not be exact.
    */
-  static boost::optional<Pose3> Align(const Point3Pairs& abPointPairs);
+  static std::optional<Pose3> Align(const Point3Pairs& abPointPairs);
 
   // Version of Pose3::Align that takes 2 matrices.
-  static boost::optional<Pose3> Align(const Matrix& a, const Matrix& b);
+  static std::optional<Pose3> Align(const Matrix& a, const Matrix& b);
 
   /// @}
   /// @name Testable
@@ -139,10 +139,10 @@ public:
   /// @{
 
   /// Exponential map at identity - create a rotation from canonical coordinates \f$ [R_x,R_y,R_z,T_x,T_y,T_z] \f$
-  static Pose3 Expmap(const Vector6& xi, OptionalJacobian<6, 6> Hxi = boost::none);
+  static Pose3 Expmap(const Vector6& xi, OptionalJacobian<6, 6> Hxi = {});
 
   /// Log map at identity - return the canonical coordinates \f$ [R_x,R_y,R_z,T_x,T_y,T_z] \f$ of this rotation
-  static Vector6 Logmap(const Pose3& pose, OptionalJacobian<6, 6> Hpose = boost::none);
+  static Vector6 Logmap(const Pose3& pose, OptionalJacobian<6, 6> Hpose = {});
 
   /**
    * Calculate Adjoint map, transforming a twist in this pose's (i.e, body) frame to the world spatial frame
@@ -157,13 +157,13 @@ public:
    * Note that H_xib = AdjointMap()
    */
   Vector6 Adjoint(const Vector6& xi_b,
-                  OptionalJacobian<6, 6> H_this = boost::none,
-                  OptionalJacobian<6, 6> H_xib = boost::none) const;
+                  OptionalJacobian<6, 6> H_this = {},
+                  OptionalJacobian<6, 6> H_xib = {}) const;
   
   /// The dual version of Adjoint
   Vector6 AdjointTranspose(const Vector6& x,
-                           OptionalJacobian<6, 6> H_this = boost::none,
-                           OptionalJacobian<6, 6> H_x = boost::none) const;
+                           OptionalJacobian<6, 6> H_this = {},
+                           OptionalJacobian<6, 6> H_x = {}) const;
 
   /**
    * Compute the [ad(w,v)] operator as defined in [Kobilarov09siggraph], pg 11
@@ -186,8 +186,8 @@ public:
    * Action of the adjointMap on a Lie-algebra vector y, with optional derivatives
    */
   static Vector6 adjoint(const Vector6& xi, const Vector6& y,
-                         OptionalJacobian<6, 6> Hxi = boost::none,
-                         OptionalJacobian<6, 6> H_y = boost::none);
+                         OptionalJacobian<6, 6> Hxi = {},
+                         OptionalJacobian<6, 6> H_y = {});
 
   // temporary fix for wrappers until case issue is resolved
   static Matrix6 adjointMap_(const Vector6 &xi) { return adjointMap(xi);}
@@ -197,8 +197,8 @@ public:
    * The dual version of adjoint action, acting on the dual space of the Lie-algebra vector space.
    */
   static Vector6 adjointTranspose(const Vector6& xi, const Vector6& y,
-                                  OptionalJacobian<6, 6> Hxi = boost::none,
-                                  OptionalJacobian<6, 6> H_y = boost::none);
+                                  OptionalJacobian<6, 6> Hxi = {},
+                                  OptionalJacobian<6, 6> H_y = {});
 
   /// Derivative of Expmap
   static Matrix6 ExpmapDerivative(const Vector6& xi);
@@ -208,8 +208,8 @@ public:
 
   // Chart at origin, depends on compile-time flag GTSAM_POSE3_EXPMAP
   struct ChartAtOrigin {
-    static Pose3 Retract(const Vector6& xi, ChartJacobian Hxi = boost::none);
-    static Vector6 Local(const Pose3& pose, ChartJacobian Hpose = boost::none);
+    static Pose3 Retract(const Vector6& xi, ChartJacobian Hxi = {});
+    static Vector6 Local(const Pose3& pose, ChartJacobian Hpose = {});
   };
 
   /**
@@ -250,7 +250,7 @@ public:
    * @return point in world coordinates
    */
   Point3 transformFrom(const Point3& point, OptionalJacobian<3, 6> Hself =
-      boost::none, OptionalJacobian<3, 3> Hpoint = boost::none) const;
+      {}, OptionalJacobian<3, 3> Hpoint = {}) const;
 
   /**
    * @brief transform many points in Pose coordinates and transform to world.
@@ -272,7 +272,7 @@ public:
    * @return point in Pose coordinates
    */
   Point3 transformTo(const Point3& point, OptionalJacobian<3, 6> Hself =
-      boost::none, OptionalJacobian<3, 3> Hpoint = boost::none) const;
+      {}, OptionalJacobian<3, 3> Hpoint = {}) const;
 
   /**
    * @brief transform many points in world coordinates and transform to Pose.
@@ -286,10 +286,10 @@ public:
   /// @{
 
   /// get rotation
-  const Rot3& rotation(OptionalJacobian<3, 6> Hself = boost::none) const;
+  const Rot3& rotation(OptionalJacobian<3, 6> Hself = {}) const;
 
   /// get translation
-  const Point3& translation(OptionalJacobian<3, 6> Hself = boost::none) const;
+  const Point3& translation(OptionalJacobian<3, 6> Hself = {}) const;
 
   /// get x
   double x() const {
@@ -314,39 +314,39 @@ public:
     * and transforms it to world coordinates wTb = wTa * aTb.
     * This is identical to compose.
     */
-  Pose3 transformPoseFrom(const Pose3& aTb, OptionalJacobian<6, 6> Hself = boost::none,
-                                            OptionalJacobian<6, 6> HaTb = boost::none) const;
+  Pose3 transformPoseFrom(const Pose3& aTb, OptionalJacobian<6, 6> Hself = {},
+                                            OptionalJacobian<6, 6> HaTb = {}) const;
 
   /** 
    *  Assuming self == wTa, takes a pose wTb in world coordinates 
    * and transforms it to local coordinates aTb = inv(wTa) * wTb 
    */
-  Pose3 transformPoseTo(const Pose3& wTb, OptionalJacobian<6, 6> Hself = boost::none,
-                                          OptionalJacobian<6, 6> HwTb = boost::none) const;
+  Pose3 transformPoseTo(const Pose3& wTb, OptionalJacobian<6, 6> Hself = {},
+                                          OptionalJacobian<6, 6> HwTb = {}) const;
 
   /**
    * Calculate range to a landmark
    * @param point 3D location of landmark
    * @return range (double)
    */
-  double range(const Point3& point, OptionalJacobian<1, 6> Hself = boost::none,
-      OptionalJacobian<1, 3> Hpoint = boost::none) const;
+  double range(const Point3& point, OptionalJacobian<1, 6> Hself = {},
+      OptionalJacobian<1, 3> Hpoint = {}) const;
 
   /**
    * Calculate range to another pose
    * @param pose Other SO(3) pose
    * @return range (double)
    */
-  double range(const Pose3& pose, OptionalJacobian<1, 6> Hself = boost::none,
-      OptionalJacobian<1, 6> Hpose = boost::none) const;
+  double range(const Pose3& pose, OptionalJacobian<1, 6> Hself = {},
+      OptionalJacobian<1, 6> Hpose = {}) const;
 
   /**
    * Calculate bearing to a landmark
    * @param point 3D location of landmark
    * @return bearing (Unit3)
    */
-  Unit3 bearing(const Point3& point, OptionalJacobian<2, 6> Hself = boost::none,
-      OptionalJacobian<2, 3> Hpoint = boost::none) const;
+  Unit3 bearing(const Point3& point, OptionalJacobian<2, 6> Hself = {},
+      OptionalJacobian<2, 3> Hpoint = {}) const;
 
   /**
    * Calculate bearing to another pose
@@ -354,8 +354,8 @@ public:
    * information is ignored.
    * @return bearing (Unit3)
    */
-  Unit3 bearing(const Pose3& pose, OptionalJacobian<2, 6> Hself = boost::none,
-      OptionalJacobian<2, 6> Hpose = boost::none) const;
+  Unit3 bearing(const Pose3& pose, OptionalJacobian<2, 6> Hself = {},
+      OptionalJacobian<2, 6> Hpose = {}) const;
 
   /// @}
   /// @name Advanced Interface
@@ -384,8 +384,8 @@ public:
    * @param s a value between 0 and 1.5
    * @param other final point of interpolation geodesic on manifold
    */
-  Pose3 slerp(double t, const Pose3& other, OptionalJacobian<6, 6> Hx = boost::none,
-                                             OptionalJacobian<6, 6> Hy = boost::none) const;
+  Pose3 slerp(double t, const Pose3& other, OptionalJacobian<6, 6> Hx = {},
+                                             OptionalJacobian<6, 6> Hy = {}) const;
 
   /// Output stream operator
   GTSAM_EXPORT
diff --git a/gtsam/geometry/Quaternion.h b/gtsam/geometry/Quaternion.h
index 2ef47d58e..f9ed2a383 100644
--- a/gtsam/geometry/Quaternion.h
+++ b/gtsam/geometry/Quaternion.h
@@ -55,14 +55,14 @@ struct traits<QUATERNION_TYPE> {
   /// @name Lie group traits
   /// @{
   static Q Compose(const Q &g, const Q & h,
-      ChartJacobian Hg = boost::none, ChartJacobian Hh = boost::none) {
+      ChartJacobian Hg = {}, ChartJacobian Hh = {}) {
     if (Hg) *Hg = h.toRotationMatrix().transpose();
     if (Hh) *Hh = I_3x3;
     return g * h;
   }
 
   static Q Between(const Q &g, const Q & h,
-      ChartJacobian Hg = boost::none, ChartJacobian Hh = boost::none) {
+      ChartJacobian Hg = {}, ChartJacobian Hh = {}) {
     Q d = g.inverse() * h;
     if (Hg) *Hg = -d.toRotationMatrix().transpose();
     if (Hh) *Hh = I_3x3;
@@ -70,14 +70,14 @@ struct traits<QUATERNION_TYPE> {
   }
 
   static Q Inverse(const Q &g,
-      ChartJacobian H = boost::none) {
+      ChartJacobian H = {}) {
     if (H) *H = -g.toRotationMatrix();
     return g.inverse();
   }
 
   /// Exponential map, using the inlined code from Eigen's conversion from axis/angle
   static Q Expmap(const Eigen::Ref<const TangentVector>& omega,
-                  ChartJacobian H = boost::none) {
+                  ChartJacobian H = {}) {
     using std::cos;
     using std::sin;
     if (H) *H = SO3::ExpmapDerivative(omega.template cast<double>());
@@ -95,7 +95,7 @@ struct traits<QUATERNION_TYPE> {
   }
 
   /// We use our own Logmap, as there is a slight bug in Eigen
-  static TangentVector Logmap(const Q& q, ChartJacobian H = boost::none) {
+  static TangentVector Logmap(const Q& q, ChartJacobian H = {}) {
     using std::acos;
     using std::sqrt;
 
@@ -145,7 +145,7 @@ struct traits<QUATERNION_TYPE> {
   /// @{
 
   static TangentVector Local(const Q& g, const Q& h,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     Q b = Between(g, h, H1, H2);
     Matrix3 D_v_b;
     TangentVector v = Logmap(b, (H1 || H2) ? &D_v_b : 0);
@@ -155,7 +155,7 @@ struct traits<QUATERNION_TYPE> {
   }
 
   static Q Retract(const Q& g, const TangentVector& v,
-      ChartJacobian H1 = boost::none, ChartJacobian H2 = boost::none) {
+      ChartJacobian H1 = {}, ChartJacobian H2 = {}) {
     Matrix3 D_h_v;
     Q b = Expmap(v,H2 ? &D_h_v : 0);
     Q h = Compose(g, b, H1, H2);
diff --git a/gtsam/geometry/Rot2.h b/gtsam/geometry/Rot2.h
index 2e9e91cd8..26e6e6b7a 100644
--- a/gtsam/geometry/Rot2.h
+++ b/gtsam/geometry/Rot2.h
@@ -21,7 +21,6 @@
 
 #include <gtsam/geometry/Point2.h>
 #include <gtsam/base/Lie.h>
-#include <boost/optional.hpp>
 
 #include <random>
 
@@ -80,7 +79,7 @@ namespace gtsam {
      * @return 2D rotation \f$ \in SO(2) \f$
      */
     static Rot2 relativeBearing(const Point2& d, OptionalJacobian<1,2> H =
-        boost::none);
+        {});
 
     /** Named constructor that behaves as atan2, i.e., y,x order (!) and normalizes */
     static Rot2 atan2(double y, double x);
@@ -123,10 +122,10 @@ namespace gtsam {
     /// @{
 
     /// Exponential map at identity - create a rotation from canonical coordinates
-    static Rot2 Expmap(const Vector1& v, ChartJacobian H = boost::none);
+    static Rot2 Expmap(const Vector1& v, ChartJacobian H = {});
 
     /// Log map at identity - return the canonical coordinates of this rotation
-    static Vector1 Logmap(const Rot2& r, ChartJacobian H = boost::none);
+    static Vector1 Logmap(const Rot2& r, ChartJacobian H = {});
 
     /** Calculate Adjoint map */
     Matrix1 AdjointMap() const { return I_1x1; }
@@ -143,10 +142,10 @@ namespace gtsam {
 
     // Chart at origin simply uses exponential map and its inverse
     struct ChartAtOrigin {
-      static Rot2 Retract(const Vector1& v, ChartJacobian H = boost::none) {
+      static Rot2 Retract(const Vector1& v, ChartJacobian H = {}) {
         return Expmap(v, H);
       }
-      static Vector1 Local(const Rot2& r, ChartJacobian H = boost::none) {
+      static Vector1 Local(const Rot2& r, ChartJacobian H = {}) {
         return Logmap(r, H);
       }
     };
@@ -160,8 +159,8 @@ namespace gtsam {
     /**
      * rotate point from rotated coordinate frame to world \f$ p^w = R_c^w p^c \f$
      */
-    Point2 rotate(const Point2& p, OptionalJacobian<2, 1> H1 = boost::none,
-        OptionalJacobian<2, 2> H2 = boost::none) const;
+    Point2 rotate(const Point2& p, OptionalJacobian<2, 1> H1 = {},
+        OptionalJacobian<2, 2> H2 = {}) const;
 
     /** syntactic sugar for rotate */
     inline Point2 operator*(const Point2& p) const {
@@ -171,8 +170,8 @@ namespace gtsam {
     /**
      * rotate point from world to rotated frame \f$ p^c = (R_c^w)^T p^w \f$
      */
-    Point2 unrotate(const Point2& p, OptionalJacobian<2, 1> H1 = boost::none,
-        OptionalJacobian<2, 2> H2 = boost::none) const;
+    Point2 unrotate(const Point2& p, OptionalJacobian<2, 1> H1 = {},
+        OptionalJacobian<2, 2> H2 = {}) const;
 
     /// @}
     /// @name Standard Interface
diff --git a/gtsam/geometry/Rot3.h b/gtsam/geometry/Rot3.h
index c3ca87d21..b98c03dce 100644
--- a/gtsam/geometry/Rot3.h
+++ b/gtsam/geometry/Rot3.h
@@ -152,13 +152,13 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
 
     /// Rotations around Z, Y, then X axes as in http://en.wikipedia.org/wiki/Rotation_matrix, counterclockwise when looking from unchanging axis.
     static Rot3 RzRyRx(double x, double y, double z,
-                       OptionalJacobian<3, 1> Hx = boost::none,
-                       OptionalJacobian<3, 1> Hy = boost::none,
-                       OptionalJacobian<3, 1> Hz = boost::none);
+                       OptionalJacobian<3, 1> Hx = {},
+                       OptionalJacobian<3, 1> Hy = {},
+                       OptionalJacobian<3, 1> Hz = {});
 
     /// Rotations around Z, Y, then X axes as in http://en.wikipedia.org/wiki/Rotation_matrix, counterclockwise when looking from unchanging axis.
     inline static Rot3 RzRyRx(const Vector& xyz,
-                              OptionalJacobian<3, 3> H = boost::none) {
+                              OptionalJacobian<3, 3> H = {}) {
       assert(xyz.size() == 3);
       Rot3 out;
       if (H) {
@@ -194,9 +194,9 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * Positive roll is to right (decreasing yaw in aircraft).
      */
     static Rot3 Ypr(double y, double p, double r,
-                    OptionalJacobian<3, 1> Hy = boost::none,
-                    OptionalJacobian<3, 1> Hp = boost::none,
-                    OptionalJacobian<3, 1> Hr = boost::none) {
+                    OptionalJacobian<3, 1> Hy = {},
+                    OptionalJacobian<3, 1> Hp = {},
+                    OptionalJacobian<3, 1> Hr = {}) {
       return RzRyRx(r, p, y, Hr, Hp, Hy);
     }
 
@@ -347,8 +347,8 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
 
     // Cayley chart around origin
     struct CayleyChart {
-    static Rot3 Retract(const Vector3& v, OptionalJacobian<3, 3> H = boost::none);
-    static Vector3 Local(const Rot3& r, OptionalJacobian<3, 3> H = boost::none);
+    static Rot3 Retract(const Vector3& v, OptionalJacobian<3, 3> H = {});
+    static Vector3 Local(const Rot3& r, OptionalJacobian<3, 3> H = {});
     };
 
     /// Retraction from R^3 to Rot3 manifold using the Cayley transform
@@ -371,7 +371,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * Exponential map at identity - create a rotation from canonical coordinates
      * \f$ [R_x,R_y,R_z] \f$ using Rodrigues' formula
      */
-    static Rot3 Expmap(const Vector3& v, OptionalJacobian<3,3> H = boost::none) {
+    static Rot3 Expmap(const Vector3& v, OptionalJacobian<3,3> H = {}) {
       if(H) *H = Rot3::ExpmapDerivative(v);
 #ifdef GTSAM_USE_QUATERNIONS
       return traits<gtsam::Quaternion>::Expmap(v);
@@ -384,7 +384,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * Log map at identity - returns the canonical coordinates
      * \f$ [R_x,R_y,R_z] \f$ of this rotation
      */
-    static Vector3 Logmap(const Rot3& R, OptionalJacobian<3,3> H = boost::none);
+    static Vector3 Logmap(const Rot3& R, OptionalJacobian<3,3> H = {});
 
     /// Derivative of Expmap
     static Matrix3 ExpmapDerivative(const Vector3& x);
@@ -397,8 +397,8 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
 
     // Chart at origin, depends on compile-time flag ROT3_DEFAULT_COORDINATES_MODE
     struct ChartAtOrigin {
-      static Rot3 Retract(const Vector3& v, ChartJacobian H = boost::none);
-      static Vector3 Local(const Rot3& r, ChartJacobian H = boost::none);
+      static Rot3 Retract(const Vector3& v, ChartJacobian H = {});
+      static Vector3 Local(const Rot3& r, ChartJacobian H = {});
     };
 
     using LieGroup<Rot3, 3>::inverse; // version with derivative
@@ -410,27 +410,27 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
     /**
      * rotate point from rotated coordinate frame to world \f$ p^w = R_c^w p^c \f$
      */
-    Point3 rotate(const Point3& p, OptionalJacobian<3,3> H1 = boost::none,
-        OptionalJacobian<3,3> H2 = boost::none) const;
+    Point3 rotate(const Point3& p, OptionalJacobian<3,3> H1 = {},
+        OptionalJacobian<3,3> H2 = {}) const;
 
     /// rotate point from rotated coordinate frame to world = R*p
     Point3 operator*(const Point3& p) const;
 
     /// rotate point from world to rotated frame \f$ p^c = (R_c^w)^T p^w \f$
-    Point3 unrotate(const Point3& p, OptionalJacobian<3,3> H1 = boost::none,
-        OptionalJacobian<3,3> H2=boost::none) const;
+    Point3 unrotate(const Point3& p, OptionalJacobian<3,3> H1 = {},
+        OptionalJacobian<3,3> H2={}) const;
 
     /// @}
     /// @name Group Action on Unit3
     /// @{
 
     /// rotate 3D direction from rotated coordinate frame to world frame
-    Unit3 rotate(const Unit3& p, OptionalJacobian<2,3> HR = boost::none,
-        OptionalJacobian<2,2> Hp = boost::none) const;
+    Unit3 rotate(const Unit3& p, OptionalJacobian<2,3> HR = {},
+        OptionalJacobian<2,2> Hp = {}) const;
 
     /// unrotate 3D direction from world frame to rotated coordinate frame
-    Unit3 unrotate(const Unit3& p, OptionalJacobian<2,3> HR = boost::none,
-        OptionalJacobian<2,2> Hp = boost::none) const;
+    Unit3 unrotate(const Unit3& p, OptionalJacobian<2,3> HR = {},
+        OptionalJacobian<2,2> Hp = {}) const;
 
     /// rotate 3D direction from rotated coordinate frame to world frame
     Unit3 operator*(const Unit3& p) const;
@@ -458,19 +458,19 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * Use RQ to calculate xyz angle representation
      * @return a vector containing x,y,z s.t. R = Rot3::RzRyRx(x,y,z)
      */
-    Vector3 xyz(OptionalJacobian<3, 3> H = boost::none) const;
+    Vector3 xyz(OptionalJacobian<3, 3> H = {}) const;
 
     /**
      * Use RQ to calculate yaw-pitch-roll angle representation
      * @return a vector containing ypr s.t. R = Rot3::Ypr(y,p,r)
      */
-    Vector3 ypr(OptionalJacobian<3, 3> H = boost::none) const;
+    Vector3 ypr(OptionalJacobian<3, 3> H = {}) const;
 
     /**
      * Use RQ to calculate roll-pitch-yaw angle representation
      * @return a vector containing rpy s.t. R = Rot3::Ypr(y,p,r)
      */
-    Vector3 rpy(OptionalJacobian<3, 3> H = boost::none) const;
+    Vector3 rpy(OptionalJacobian<3, 3> H = {}) const;
 
     /**
      * Accessor to get to component of angle representations
@@ -478,7 +478,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * you should instead use xyz() or ypr()
      * TODO: make this more efficient
      */
-    double roll(OptionalJacobian<1, 3> H = boost::none) const;
+    double roll(OptionalJacobian<1, 3> H = {}) const;
 
     /**
      * Accessor to get to component of angle representations
@@ -486,7 +486,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * you should instead use xyz() or ypr()
      * TODO: make this more efficient
      */
-    double pitch(OptionalJacobian<1, 3> H = boost::none) const;
+    double pitch(OptionalJacobian<1, 3> H = {}) const;
 
     /**
      * Accessor to get to component of angle representations
@@ -494,7 +494,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
      * you should instead use xyz() or ypr()
      * TODO: make this more efficient
      */
-    double yaw(OptionalJacobian<1, 3> H = boost::none) const;
+    double yaw(OptionalJacobian<1, 3> H = {}) const;
 
     /// @}
     /// @name Advanced Interface
@@ -572,7 +572,7 @@ class GTSAM_EXPORT Rot3 : public LieGroup<Rot3, 3> {
    * @return a vector [thetax, thetay, thetaz] in radians.
    */
   GTSAM_EXPORT std::pair<Matrix3, Vector3> RQ(
-      const Matrix3& A, OptionalJacobian<3, 9> H = boost::none);
+      const Matrix3& A, OptionalJacobian<3, 9> H = {});
 
   template<>
   struct traits<Rot3> : public internal::LieGroup<Rot3> {};
diff --git a/gtsam/geometry/SO3.h b/gtsam/geometry/SO3.h
index 0463bc2e8..6f78bed4e 100644
--- a/gtsam/geometry/SO3.h
+++ b/gtsam/geometry/SO3.h
@@ -121,7 +121,7 @@ namespace so3 {
  * We only provide the 9*9 derivative in the first argument M.
  */
 GTSAM_EXPORT Matrix3 compose(const Matrix3& M, const SO3& R,
-                OptionalJacobian<9, 9> H = boost::none);
+                OptionalJacobian<9, 9> H = {});
 
 /// (constant) Jacobian of compose wrpt M
 GTSAM_EXPORT Matrix99 Dcompose(const SO3& R);
@@ -170,13 +170,13 @@ class DexpFunctor : public ExpmapFunctor {
   const Matrix3& dexp() const { return dexp_; }
 
   /// Multiplies with dexp(), with optional derivatives
-  GTSAM_EXPORT Vector3 applyDexp(const Vector3& v, OptionalJacobian<3, 3> H1 = boost::none,
-                    OptionalJacobian<3, 3> H2 = boost::none) const;
+  GTSAM_EXPORT Vector3 applyDexp(const Vector3& v, OptionalJacobian<3, 3> H1 = {},
+                    OptionalJacobian<3, 3> H2 = {}) const;
 
   /// Multiplies with dexp().inverse(), with optional derivatives
   GTSAM_EXPORT Vector3 applyInvDexp(const Vector3& v,
-                       OptionalJacobian<3, 3> H1 = boost::none,
-                       OptionalJacobian<3, 3> H2 = boost::none) const;
+                       OptionalJacobian<3, 3> H1 = {},
+                       OptionalJacobian<3, 3> H2 = {}) const;
 };
 }  //  namespace so3
 
diff --git a/gtsam/geometry/SO4.h b/gtsam/geometry/SO4.h
index 7503b012b..529935006 100644
--- a/gtsam/geometry/SO4.h
+++ b/gtsam/geometry/SO4.h
@@ -70,13 +70,13 @@ Vector6 SO4::ChartAtOrigin::Local(const SO4 &Q, ChartJacobian H);
 /**
  * Project to top-left 3*3 matrix. Note this is *not* in general \in SO(3).
  */
-GTSAM_EXPORT Matrix3 topLeft(const SO4 &Q, OptionalJacobian<9, 6> H = boost::none);
+GTSAM_EXPORT Matrix3 topLeft(const SO4 &Q, OptionalJacobian<9, 6> H = {});
 
 /**
  * Project to Stiefel manifold of 4*3 orthonormal 3-frames in R^4, i.e., pi(Q)
  * -> \f$ S \in St(3,4) \f$.
  */
-GTSAM_EXPORT Matrix43 stiefel(const SO4 &Q, OptionalJacobian<12, 6> H = boost::none);
+GTSAM_EXPORT Matrix43 stiefel(const SO4 &Q, OptionalJacobian<12, 6> H = {});
 
 /** Serialization function */
 template <class Archive>
diff --git a/gtsam/geometry/SOn.h b/gtsam/geometry/SOn.h
index 2c8261668..b8b9deb3b 100644
--- a/gtsam/geometry/SOn.h
+++ b/gtsam/geometry/SOn.h
@@ -242,12 +242,12 @@ class SO : public LieGroup<SO<N>, internal::DimensionSO(N)> {
      * Retract uses Cayley map. See note about xi element order in Hat.
      * Deafault implementation has no Jacobian implemented
      */
-    static SO Retract(const TangentVector& xi, ChartJacobian H = boost::none);
+    static SO Retract(const TangentVector& xi, ChartJacobian H = {});
 
     /**
      * Inverse of Retract. See note about xi element order in Hat.
      */
-    static TangentVector Local(const SO& R, ChartJacobian H = boost::none);
+    static TangentVector Local(const SO& R, ChartJacobian H = {});
   };
 
   // Return dynamic identity DxD Jacobian for given SO(n)
@@ -267,7 +267,7 @@ class SO : public LieGroup<SO<N>, internal::DimensionSO(N)> {
   /**
    * Exponential map at identity - create a rotation from canonical coordinates
    */
-  static SO Expmap(const TangentVector& omega, ChartJacobian H = boost::none);
+  static SO Expmap(const TangentVector& omega, ChartJacobian H = {});
 
   /// Derivative of Expmap, currently only defined for SO3
   static MatrixDD ExpmapDerivative(const TangentVector& omega);
@@ -275,7 +275,7 @@ class SO : public LieGroup<SO<N>, internal::DimensionSO(N)> {
   /**
    * Log map at identity - returns the canonical coordinates of this rotation
    */
-  static TangentVector Logmap(const SO& R, ChartJacobian H = boost::none);
+  static TangentVector Logmap(const SO& R, ChartJacobian H = {});
 
   /// Derivative of Logmap, currently only defined for SO3
   static MatrixDD LogmapDerivative(const TangentVector& omega);
@@ -293,7 +293,7 @@ class SO : public LieGroup<SO<N>, internal::DimensionSO(N)> {
    * X and fixed-size Jacobian if dimension is known at compile time.
    * */
   VectorN2 vec(OptionalJacobian<internal::NSquaredSO(N), dimension> H =
-                   boost::none) const;
+                   {}) const;
 
   /// Calculate N^2 x dim matrix of vectorized Lie algebra generators for SO(N)
   template <int N_ = N, typename = IsFixed<N_>>
diff --git a/gtsam/geometry/Similarity2.h b/gtsam/geometry/Similarity2.h
index ad4b82e09..47281b383 100644
--- a/gtsam/geometry/Similarity2.h
+++ b/gtsam/geometry/Similarity2.h
@@ -143,20 +143,20 @@ class GTSAM_EXPORT Similarity2 : public LieGroup<Similarity2, 4> {
    * \f$ [t_x, t_y, \delta, \lambda] \f$
    */
   static Vector4 Logmap(const Similarity2& S,  //
-                        OptionalJacobian<4, 4> Hm = boost::none);
+                        OptionalJacobian<4, 4> Hm = {});
 
   /// Exponential map at the identity
   static Similarity2 Expmap(const Vector4& v,  //
-                            OptionalJacobian<4, 4> Hm = boost::none);
+                            OptionalJacobian<4, 4> Hm = {});
 
   /// Chart at the origin
   struct ChartAtOrigin {
     static Similarity2 Retract(const Vector4& v,
-                               ChartJacobian H = boost::none) {
+                               ChartJacobian H = {}) {
       return Similarity2::Expmap(v, H);
     }
     static Vector4 Local(const Similarity2& other,
-                         ChartJacobian H = boost::none) {
+                         ChartJacobian H = {}) {
       return Similarity2::Logmap(other, H);
     }
   };
diff --git a/gtsam/geometry/Similarity3.h b/gtsam/geometry/Similarity3.h
index 41d9d9965..aa0f3a62a 100644
--- a/gtsam/geometry/Similarity3.h
+++ b/gtsam/geometry/Similarity3.h
@@ -98,8 +98,8 @@ class GTSAM_EXPORT Similarity3 : public LieGroup<Similarity3, 7> {
 
   /// Action on a point p is s*(R*p+t)
   Point3 transformFrom(const Point3& p,                          //
-                       OptionalJacobian<3, 7> H1 = boost::none,  //
-                       OptionalJacobian<3, 3> H2 = boost::none) const;
+                       OptionalJacobian<3, 7> H1 = {},  //
+                       OptionalJacobian<3, 3> H2 = {}) const;
 
   /**
    * Action on a pose T.
@@ -142,21 +142,21 @@ class GTSAM_EXPORT Similarity3 : public LieGroup<Similarity3, 7> {
    * \f$ [R_x,R_y,R_z, t_x, t_y, t_z, \lambda] \f$
    */
   static Vector7 Logmap(const Similarity3& s,  //
-                        OptionalJacobian<7, 7> Hm = boost::none);
+                        OptionalJacobian<7, 7> Hm = {});
 
   /** Exponential map at the identity
    */
   static Similarity3 Expmap(const Vector7& v,  //
-                            OptionalJacobian<7, 7> Hm = boost::none);
+                            OptionalJacobian<7, 7> Hm = {});
 
   /// Chart at the origin
   struct ChartAtOrigin {
     static Similarity3 Retract(const Vector7& v,
-                               ChartJacobian H = boost::none) {
+                               ChartJacobian H = {}) {
       return Similarity3::Expmap(v, H);
     }
     static Vector7 Local(const Similarity3& other,
-                         ChartJacobian H = boost::none) {
+                         ChartJacobian H = {}) {
       return Similarity3::Logmap(other, H);
     }
   };
diff --git a/gtsam/geometry/SphericalCamera.cpp b/gtsam/geometry/SphericalCamera.cpp
index 58a29dc09..5c6a2b3a4 100644
--- a/gtsam/geometry/SphericalCamera.cpp
+++ b/gtsam/geometry/SphericalCamera.cpp
@@ -96,7 +96,7 @@ Vector2 SphericalCamera::reprojectionError(
     Matrix23 H_project_point;
     Matrix22 H_error;
     Unit3 projected = project2(point, H_project_pose, H_project_point);
-    Vector2 error = measured.errorVector(projected, boost::none, H_error);
+    Vector2 error = measured.errorVector(projected, {}, H_error);
     if (Dpose) *Dpose = H_error * H_project_pose;
     if (Dpoint) *Dpoint = H_error * H_project_point;
     return error;
diff --git a/gtsam/geometry/SphericalCamera.h b/gtsam/geometry/SphericalCamera.h
index 53b67241f..dd3bc7420 100644
--- a/gtsam/geometry/SphericalCamera.h
+++ b/gtsam/geometry/SphericalCamera.h
@@ -152,16 +152,16 @@ class GTSAM_EXPORT SphericalCamera {
    * @param point 3D point in world coordinates
    * @return the intrinsic coordinates of the projected point
    */
-  Unit3 project2(const Point3& pw, OptionalJacobian<2, 6> Dpose = boost::none,
-                 OptionalJacobian<2, 3> Dpoint = boost::none) const;
+  Unit3 project2(const Point3& pw, OptionalJacobian<2, 6> Dpose = {},
+                 OptionalJacobian<2, 3> Dpoint = {}) const;
 
   /** Project point into the image
    * (note: there is no CheiralityException for a spherical camera)
    * @param point 3D direction in world coordinates
    * @return the intrinsic coordinates of the projected point
    */
-  Unit3 project2(const Unit3& pwu, OptionalJacobian<2, 6> Dpose = boost::none,
-                 OptionalJacobian<2, 2> Dpoint = boost::none) const;
+  Unit3 project2(const Unit3& pwu, OptionalJacobian<2, 6> Dpose = {},
+                 OptionalJacobian<2, 2> Dpoint = {}) const;
 
   /// backproject a 2-dimensional point to a 3-dimensional point at given depth
   Point3 backproject(const Unit3& p, const double depth) const;
@@ -174,16 +174,16 @@ class GTSAM_EXPORT SphericalCamera {
    * @param point 3D point in world coordinates
    * @return the intrinsic coordinates of the projected point
    */
-  Unit3 project(const Point3& point, OptionalJacobian<2, 6> Dpose = boost::none,
-                OptionalJacobian<2, 3> Dpoint = boost::none) const;
+  Unit3 project(const Point3& point, OptionalJacobian<2, 6> Dpose = {},
+                OptionalJacobian<2, 3> Dpoint = {}) const;
 
   /** Compute reprojection error for a given 3D point in world coordinates
    * @param point 3D point in world coordinates
    * @return the tangent space error between the projection and the measurement
    */
   Vector2 reprojectionError(const Point3& point, const Unit3& measured,
-                            OptionalJacobian<2, 6> Dpose = boost::none,
-                            OptionalJacobian<2, 3> Dpoint = boost::none) const;
+                            OptionalJacobian<2, 6> Dpose = {},
+                            OptionalJacobian<2, 3> Dpoint = {}) const;
   /// @}
 
   /// move a cameras according to d
diff --git a/gtsam/geometry/StereoCamera.h b/gtsam/geometry/StereoCamera.h
index 603476278..6ccebd8c2 100644
--- a/gtsam/geometry/StereoCamera.h
+++ b/gtsam/geometry/StereoCamera.h
@@ -143,7 +143,7 @@ public:
    * @param H2 derivative with respect to point
    */
   StereoPoint2 project2(const Point3& point, OptionalJacobian<3, 6> H1 =
-      boost::none, OptionalJacobian<3, 3> H2 = boost::none) const;
+      {}, OptionalJacobian<3, 3> H2 = {}) const;
 
   /// back-project a measurement
   Point3 backproject(const StereoPoint2& z) const;
@@ -153,8 +153,8 @@ public:
    * @param H2 derivative with respect to point
    */
   Point3 backproject2(const StereoPoint2& z,
-                      OptionalJacobian<3, 6> H1 = boost::none,
-                      OptionalJacobian<3, 3> H2 = boost::none) const;
+                      OptionalJacobian<3, 6> H1 = {},
+                      OptionalJacobian<3, 3> H2 = {}) const;
 
   /// @}
   /// @name Deprecated
@@ -167,8 +167,8 @@ public:
    * @param H3 IGNORED (for calibration)
    */
   StereoPoint2 project(const Point3& point, OptionalJacobian<3, 6> H1,
-      OptionalJacobian<3, 3> H2 = boost::none, OptionalJacobian<3, 0> H3 =
-          boost::none) const;
+      OptionalJacobian<3, 3> H2 = {}, OptionalJacobian<3, 0> H3 =
+          {}) const;
 
   /// for Nonlinear Triangulation
   Vector defaultErrorWhenTriangulatingBehindCamera() const {
diff --git a/gtsam/geometry/Unit3.cpp b/gtsam/geometry/Unit3.cpp
index 6f70d840e..039b93a3a 100644
--- a/gtsam/geometry/Unit3.cpp
+++ b/gtsam/geometry/Unit3.cpp
@@ -109,8 +109,8 @@ const Matrix32& Unit3::basis(OptionalJacobian<6, 2> H) const {
       jacobian.block<3, 2>(3, 0) = H_b2_n * H_n_p + H_b2_b1 * H_b1_p;
 
       // Cache the result and jacobian
-      H_B_.reset(jacobian);
-      B_.reset(B);
+      H_B_ = (jacobian);
+      B_ = (B);
     }
 
     // Return cached jacobian, possibly computed just above
@@ -126,7 +126,7 @@ const Matrix32& Unit3::basis(OptionalJacobian<6, 2> H) const {
     const Point3 B1 = gtsam::cross(n, axis);
     B.col(0) = normalize(B1);
     B.col(1) = gtsam::cross(n, B.col(0));
-    B_.reset(B);
+    B_ = (B);
   }
 
   return *B_;
diff --git a/gtsam/geometry/Unit3.h b/gtsam/geometry/Unit3.h
index ebd5c63c9..8f629786d 100644
--- a/gtsam/geometry/Unit3.h
+++ b/gtsam/geometry/Unit3.h
@@ -28,7 +28,6 @@
 #include <gtsam/base/Matrix.h>
 #include <gtsam/dllexport.h>
 
-#include <boost/optional.hpp>
 
 #include <random>
 #include <string>
@@ -45,8 +44,8 @@ class GTSAM_EXPORT Unit3 {
 private:
 
   Vector3 p_; ///< The location of the point on the unit sphere
-  mutable boost::optional<Matrix32> B_; ///< Cached basis
-  mutable boost::optional<Matrix62> H_B_; ///< Cached basis derivative
+  mutable std::optional<Matrix32> B_; ///< Cached basis
+  mutable std::optional<Matrix62> H_B_; ///< Cached basis derivative
 
 #ifdef GTSAM_USE_TBB
   mutable std::mutex B_mutex_; ///< Mutex to protect the cached basis.
@@ -98,7 +97,7 @@ public:
 
   /// Named constructor from Point3 with optional Jacobian
   static Unit3 FromPoint3(const Point3& point, //
-      OptionalJacobian<2, 3> H = boost::none);
+      OptionalJacobian<2, 3> H = {});
 
   /**
    * Random direction, using boost::uniform_on_sphere
@@ -133,16 +132,16 @@ public:
    * tangent to the sphere at the current direction.
    * Provides derivatives of the basis with the two basis vectors stacked up as a 6x1.
    */
-  const Matrix32& basis(OptionalJacobian<6, 2> H = boost::none) const;
+  const Matrix32& basis(OptionalJacobian<6, 2> H = {}) const;
 
   /// Return skew-symmetric associated with 3D point on unit sphere
   Matrix3 skew() const;
 
   /// Return unit-norm Point3
-  Point3 point3(OptionalJacobian<3, 2> H = boost::none) const;
+  Point3 point3(OptionalJacobian<3, 2> H = {}) const;
 
   /// Return unit-norm Vector
-  Vector3 unitVector(OptionalJacobian<3, 2> H = boost::none) const;
+  Vector3 unitVector(OptionalJacobian<3, 2> H = {}) const;
 
   /// Return scaled direction as Point3
   friend Point3 operator*(double s, const Unit3& d) {
@@ -150,20 +149,20 @@ public:
   }
 
   /// Return dot product with q
-  double dot(const Unit3& q, OptionalJacobian<1,2> H1 = boost::none, //
-                             OptionalJacobian<1,2> H2 = boost::none) const;
+  double dot(const Unit3& q, OptionalJacobian<1,2> H1 = {}, //
+                             OptionalJacobian<1,2> H2 = {}) const;
 
   /// Signed, vector-valued error between two directions
   /// @deprecated, errorVector has the proper derivatives, this confusingly has only the second.
-  Vector2 error(const Unit3& q, OptionalJacobian<2, 2> H_q = boost::none) const;
+  Vector2 error(const Unit3& q, OptionalJacobian<2, 2> H_q = {}) const;
 
   /// Signed, vector-valued error between two directions
   /// NOTE(hayk): This method has zero derivatives if this (p) and q are orthogonal.
-  Vector2 errorVector(const Unit3& q, OptionalJacobian<2, 2> H_p = boost::none, //
-                      OptionalJacobian<2, 2> H_q = boost::none) const;
+  Vector2 errorVector(const Unit3& q, OptionalJacobian<2, 2> H_p = {}, //
+                      OptionalJacobian<2, 2> H_q = {}) const;
 
   /// Distance between two directions
-  double distance(const Unit3& q, OptionalJacobian<1, 2> H = boost::none) const;
+  double distance(const Unit3& q, OptionalJacobian<1, 2> H = {}) const;
 
   /// Cross-product between two Unit3s
   Unit3 cross(const Unit3& q) const {
@@ -196,7 +195,7 @@ public:
   };
 
   /// The retract function
-  Unit3 retract(const Vector2& v, OptionalJacobian<2,2> H = boost::none) const;
+  Unit3 retract(const Vector2& v, OptionalJacobian<2,2> H = {}) const;
 
   /// The local coordinates function
   Vector2 localCoordinates(const Unit3& s) const;
diff --git a/gtsam/geometry/concepts.h b/gtsam/geometry/concepts.h
index bafb62418..30d87ac53 100644
--- a/gtsam/geometry/concepts.h
+++ b/gtsam/geometry/concepts.h
@@ -25,7 +25,6 @@
 #pragma once
 
 #include <gtsam/base/Matrix.h>
-#include <boost/optional.hpp>
 
 namespace gtsam {
 
diff --git a/gtsam/geometry/geometry.i b/gtsam/geometry/geometry.i
index 2f1810dbb..e9929227a 100644
--- a/gtsam/geometry/geometry.i
+++ b/gtsam/geometry/geometry.i
@@ -376,8 +376,8 @@ class Pose2 {
   Pose2(const gtsam::Rot2& r, const gtsam::Point2& t);
   Pose2(Vector v);
 
-  static boost::optional<gtsam::Pose2> Align(const gtsam::Point2Pairs& abPointPairs);
-  static boost::optional<gtsam::Pose2> Align(const gtsam::Matrix& a, const gtsam::Matrix& b);
+  static std::optional<gtsam::Pose2> Align(const gtsam::Point2Pairs& abPointPairs);
+  static std::optional<gtsam::Pose2> Align(const gtsam::Matrix& a, const gtsam::Matrix& b);
 
   // Testable
   void print(string s = "") const;
@@ -440,8 +440,8 @@ class Pose3 {
   Pose3(const gtsam::Pose2& pose2);
   Pose3(Matrix mat);
 
-  static boost::optional<gtsam::Pose3> Align(const gtsam::Point3Pairs& abPointPairs);
-  static boost::optional<gtsam::Pose3> Align(const gtsam::Matrix& a, const gtsam::Matrix& b);
+  static std::optional<gtsam::Pose3> Align(const gtsam::Point3Pairs& abPointPairs);
+  static std::optional<gtsam::Pose3> Align(const gtsam::Matrix& a, const gtsam::Matrix& b);
 
   // Testable
   void print(string s = "") const;
diff --git a/gtsam/geometry/tests/testCal3DS2.cpp b/gtsam/geometry/tests/testCal3DS2.cpp
index 7ef6e5001..e9ee39836 100644
--- a/gtsam/geometry/tests/testCal3DS2.cpp
+++ b/gtsam/geometry/tests/testCal3DS2.cpp
@@ -57,7 +57,7 @@ Point2 uncalibrate_(const Cal3DS2& k, const Point2& pt) {
 /* ************************************************************************* */
 TEST(Cal3DS2, Duncalibrate1) {
   Matrix computed;
-  K.uncalibrate(p, computed, boost::none);
+  K.uncalibrate(p, computed, {});
   Matrix numerical = numericalDerivative21(uncalibrate_, K, p, 1e-7);
   CHECK(assert_equal(numerical, computed, 1e-5));
   Matrix separate = K.D2d_calibration(p);
@@ -67,7 +67,7 @@ TEST(Cal3DS2, Duncalibrate1) {
 /* ************************************************************************* */
 TEST(Cal3DS2, Duncalibrate2) {
   Matrix computed;
-  K.uncalibrate(p, boost::none, computed);
+  K.uncalibrate(p, {}, computed);
   Matrix numerical = numericalDerivative22(uncalibrate_, K, p, 1e-7);
   CHECK(assert_equal(numerical, computed, 1e-5));
   Matrix separate = K.D2d_intrinsic(p);
diff --git a/gtsam/geometry/tests/testCal3Unified.cpp b/gtsam/geometry/tests/testCal3Unified.cpp
index 648bb358c..0f58bd82a 100644
--- a/gtsam/geometry/tests/testCal3Unified.cpp
+++ b/gtsam/geometry/tests/testCal3Unified.cpp
@@ -68,7 +68,7 @@ Point2 uncalibrate_(const Cal3Unified& k, const Point2& pt) {
 /* ************************************************************************* */
 TEST(Cal3Unified, Duncalibrate1) {
   Matrix computed;
-  K.uncalibrate(p, computed, boost::none);
+  K.uncalibrate(p, computed, {});
   Matrix numerical = numericalDerivative21(uncalibrate_, K, p, 1e-7);
   CHECK(assert_equal(numerical, computed, 1e-6));
 }
@@ -76,7 +76,7 @@ TEST(Cal3Unified, Duncalibrate1) {
 /* ************************************************************************* */
 TEST(Cal3Unified, Duncalibrate2) {
   Matrix computed;
-  K.uncalibrate(p, boost::none, computed);
+  K.uncalibrate(p, {}, computed);
   Matrix numerical = numericalDerivative22(uncalibrate_, K, p, 1e-7);
   CHECK(assert_equal(numerical, computed, 1e-6));
 }
diff --git a/gtsam/geometry/tests/testCal3_S2.cpp b/gtsam/geometry/tests/testCal3_S2.cpp
index 41be5ea8e..68d5e238b 100644
--- a/gtsam/geometry/tests/testCal3_S2.cpp
+++ b/gtsam/geometry/tests/testCal3_S2.cpp
@@ -64,7 +64,7 @@ Point2 uncalibrate_(const Cal3_S2& k, const Point2& pt) {
 
 TEST(Cal3_S2, Duncalibrate1) {
   Matrix25 computed;
-  K.uncalibrate(p, computed, boost::none);
+  K.uncalibrate(p, computed, {});
   Matrix numerical = numericalDerivative21(uncalibrate_, K, p);
   CHECK(assert_equal(numerical, computed, 1e-8));
 }
@@ -72,7 +72,7 @@ TEST(Cal3_S2, Duncalibrate1) {
 /* ************************************************************************* */
 TEST(Cal3_S2, Duncalibrate2) {
   Matrix computed;
-  K.uncalibrate(p, boost::none, computed);
+  K.uncalibrate(p, {}, computed);
   Matrix numerical = numericalDerivative22(uncalibrate_, K, p);
   CHECK(assert_equal(numerical, computed, 1e-9));
 }
@@ -84,7 +84,7 @@ Point2 calibrate_(const Cal3_S2& k, const Point2& pt) {
 /* ************************************************************************* */
 TEST(Cal3_S2, Dcalibrate1) {
   Matrix computed;
-  Point2 expected = K.calibrate(p_uv, computed, boost::none);
+  Point2 expected = K.calibrate(p_uv, computed, {});
   Matrix numerical = numericalDerivative21(calibrate_, K, p_uv);
   CHECK(assert_equal(expected, p_xy, 1e-8));
   CHECK(assert_equal(numerical, computed, 1e-8));
@@ -93,7 +93,7 @@ TEST(Cal3_S2, Dcalibrate1) {
 /* ************************************************************************* */
 TEST(Cal3_S2, Dcalibrate2) {
   Matrix computed;
-  Point2 expected = K.calibrate(p_uv, boost::none, computed);
+  Point2 expected = K.calibrate(p_uv, {}, computed);
   Matrix numerical = numericalDerivative22(calibrate_, K, p_uv);
   CHECK(assert_equal(expected, p_xy, 1e-8));
   CHECK(assert_equal(numerical, computed, 1e-8));
diff --git a/gtsam/geometry/tests/testCalibratedCamera.cpp b/gtsam/geometry/tests/testCalibratedCamera.cpp
index 0fb0754fe..27f882ff5 100644
--- a/gtsam/geometry/tests/testCalibratedCamera.cpp
+++ b/gtsam/geometry/tests/testCalibratedCamera.cpp
@@ -54,7 +54,7 @@ TEST(CalibratedCamera, Create) {
 
   // Check derivative
   std::function<CalibratedCamera(Pose3)> f =  //
-      std::bind(CalibratedCamera::Create, std::placeholders::_1, boost::none);
+      std::bind(CalibratedCamera::Create, std::placeholders::_1, nullptr);
   Matrix numericalH = numericalDerivative11<CalibratedCamera, Pose3>(f, kDefaultPose);
   EXPECT(assert_equal(numericalH, actualH, 1e-9));
 }
diff --git a/gtsam/geometry/tests/testEssentialMatrix.cpp b/gtsam/geometry/tests/testEssentialMatrix.cpp
index ff8c61f35..bd4568118 100644
--- a/gtsam/geometry/tests/testEssentialMatrix.cpp
+++ b/gtsam/geometry/tests/testEssentialMatrix.cpp
@@ -40,17 +40,21 @@ TEST(EssentialMatrix, FromRotationAndDirection) {
       trueE, EssentialMatrix::FromRotationAndDirection(trueRotation, trueDirection, actualH1, actualH2),
       1e-8));
 
-  Matrix expectedH1 = numericalDerivative11<EssentialMatrix, Rot3>(
-      std::bind(EssentialMatrix::FromRotationAndDirection,
-                std::placeholders::_1, trueDirection, boost::none, boost::none),
-      trueRotation);
-  EXPECT(assert_equal(expectedH1, actualH1, 1e-7));
+  {
+    std::function<EssentialMatrix(const Rot3&)> fn = [](const Rot3& R) {
+      return EssentialMatrix::FromRotationAndDirection(R, trueDirection);
+    };
+    Matrix expectedH1 = numericalDerivative11<EssentialMatrix, Rot3>(fn, trueRotation);
+    EXPECT(assert_equal(expectedH1, actualH1, 1e-7));
+  }
 
-  Matrix expectedH2 = numericalDerivative11<EssentialMatrix, Unit3>(
-      std::bind(EssentialMatrix::FromRotationAndDirection, trueRotation,
-                std::placeholders::_1, boost::none, boost::none),
-      trueDirection);
-  EXPECT(assert_equal(expectedH2, actualH2, 1e-7));
+  {
+    std::function<EssentialMatrix(const Unit3&)> fn = [](const Unit3& t) {
+      return EssentialMatrix::FromRotationAndDirection(trueRotation, t);
+    };
+    Matrix expectedH2 = numericalDerivative11<EssentialMatrix, Unit3>(fn, trueDirection);
+    EXPECT(assert_equal(expectedH2, actualH2, 1e-7));
+  }
 }
 
 //*************************************************************************
@@ -174,8 +178,10 @@ TEST (EssentialMatrix, FromPose3_a) {
   Matrix actualH;
   Pose3 pose(trueRotation, trueTranslation); // Pose between two cameras
   EXPECT(assert_equal(trueE, EssentialMatrix::FromPose3(pose, actualH), 1e-8));
-  Matrix expectedH = numericalDerivative11<EssentialMatrix, Pose3>(
-      std::bind(EssentialMatrix::FromPose3, std::placeholders::_1, boost::none), pose);
+  std::function<EssentialMatrix(const Pose3&)> fn = [](const Pose3& pose) {
+    return EssentialMatrix::FromPose3(pose);
+  };
+  Matrix expectedH = numericalDerivative11<EssentialMatrix, Pose3>(fn, pose);
   EXPECT(assert_equal(expectedH, actualH, 1e-7));
 }
 
@@ -187,8 +193,10 @@ TEST (EssentialMatrix, FromPose3_b) {
   EssentialMatrix E(c1Rc2, Unit3(c1Tc2));
   Pose3 pose(c1Rc2, c1Tc2); // Pose between two cameras
   EXPECT(assert_equal(E, EssentialMatrix::FromPose3(pose, actualH), 1e-8));
-  Matrix expectedH = numericalDerivative11<EssentialMatrix, Pose3>(
-      std::bind(EssentialMatrix::FromPose3, std::placeholders::_1, boost::none), pose);
+  std::function<EssentialMatrix(const Pose3&)> fn = [](const Pose3& pose) {
+    return EssentialMatrix::FromPose3(pose);
+  };
+  Matrix expectedH = numericalDerivative11<EssentialMatrix, Pose3>(fn, pose);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
diff --git a/gtsam/geometry/tests/testOrientedPlane3.cpp b/gtsam/geometry/tests/testOrientedPlane3.cpp
index 41b152557..f27b5070b 100644
--- a/gtsam/geometry/tests/testOrientedPlane3.cpp
+++ b/gtsam/geometry/tests/testOrientedPlane3.cpp
@@ -23,7 +23,6 @@
 
 using namespace std::placeholders;
 using namespace gtsam;
-using boost::none;
 
 GTSAM_CONCEPT_TESTABLE_INST(OrientedPlane3)
 GTSAM_CONCEPT_MANIFOLD_INST(OrientedPlane3)
@@ -57,17 +56,17 @@ TEST(OrientedPlane3, transform) {
                     gtsam::Point3(2.0, 3.0, 4.0));
   OrientedPlane3 plane(-1, 0, 0, 5);
   OrientedPlane3 expectedPlane(-sqrt(2.0) / 2.0, -sqrt(2.0) / 2.0, 0.0, 3);
-  OrientedPlane3 transformedPlane = plane.transform(pose, none, none);
+  OrientedPlane3 transformedPlane = plane.transform(pose, {}, {});
   EXPECT(assert_equal(expectedPlane, transformedPlane, 1e-5));
 
   // Test the jacobians of transform
   Matrix actualH1, expectedH1, actualH2, expectedH2;
   expectedH1 = numericalDerivative21(transform_, plane, pose);
-  plane.transform(pose, actualH1, none);
+  plane.transform(pose, actualH1, {});
   EXPECT(assert_equal(expectedH1, actualH1, 1e-5));
 
   expectedH2 = numericalDerivative22(transform_, plane, pose);
-  plane.transform(pose, none, actualH2);
+  plane.transform(pose, {}, actualH2);
   EXPECT(assert_equal(expectedH2, actualH2, 1e-5));
 }
 
@@ -135,8 +134,9 @@ TEST(OrientedPlane3, errorVector) {
   EXPECT(assert_equal(plane1.distance() - plane2.distance(), actual[2]));
 
   std::function<Vector3(const OrientedPlane3&, const OrientedPlane3&)> f =
-      std::bind(&OrientedPlane3::errorVector, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+    [](const OrientedPlane3& p1, const OrientedPlane3& p2) {
+      return p1.errorVector(p2);
+    };
   expectedH1 = numericalDerivative21(f, plane1, plane2);
   expectedH2 = numericalDerivative22(f, plane1, plane2);
   EXPECT(assert_equal(expectedH1, actualH1, 1e-5));
@@ -147,8 +147,10 @@ TEST(OrientedPlane3, errorVector) {
 TEST(OrientedPlane3, jacobian_retract) {
   OrientedPlane3 plane(-1, 0.1, 0.2, 5);
   Matrix33 H_actual;
-  std::function<OrientedPlane3(const Vector3&)> f = std::bind(
-      &OrientedPlane3::retract, plane, std::placeholders::_1, boost::none);
+  std::function<OrientedPlane3(const Vector3&)> f = [&plane](const Vector3& v) {
+    return plane.retract(v);
+  };
+
   {
       Vector3 v(-0.1, 0.2, 0.3);
       plane.retract(v, H_actual);
@@ -168,8 +170,9 @@ TEST(OrientedPlane3, jacobian_normal) {
   Matrix23 H_actual, H_expected;
   OrientedPlane3 plane(-1, 0.1, 0.2, 5);
 
-  std::function<Unit3(const OrientedPlane3&)> f = std::bind(
-      &OrientedPlane3::normal, std::placeholders::_1, boost::none);
+  std::function<Unit3(const OrientedPlane3&)> f = [](const OrientedPlane3& p) {
+    return p.normal();
+  };
 
   H_expected = numericalDerivative11(f, plane);
   plane.normal(H_actual);
@@ -181,8 +184,9 @@ TEST(OrientedPlane3, jacobian_distance) {
   Matrix13 H_actual, H_expected;
   OrientedPlane3 plane(-1, 0.1, 0.2, 5);
 
-  std::function<double(const OrientedPlane3&)> f = std::bind(
-      &OrientedPlane3::distance, std::placeholders::_1, boost::none);
+  std::function<double(const OrientedPlane3&)> f = [](const OrientedPlane3& p) {
+    return p.distance();
+  };
 
   H_expected = numericalDerivative11(f, plane);
   plane.distance(H_actual);
diff --git a/gtsam/geometry/tests/testPinholeCamera.cpp b/gtsam/geometry/tests/testPinholeCamera.cpp
index 0679a4609..6b5d93627 100644
--- a/gtsam/geometry/tests/testPinholeCamera.cpp
+++ b/gtsam/geometry/tests/testPinholeCamera.cpp
@@ -67,7 +67,7 @@ TEST(PinholeCamera, Create) {
   // Check derivative
   std::function<Camera(Pose3, Cal3_S2)> f =  //
       std::bind(Camera::Create, std::placeholders::_1, std::placeholders::_2,
-                boost::none, boost::none);
+                nullptr, nullptr);
   Matrix numericalH1 = numericalDerivative21<Camera,Pose3,Cal3_S2>(f,pose,K);
   EXPECT(assert_equal(numericalH1, actualH1, 1e-9));
   Matrix numericalH2 = numericalDerivative22<Camera,Pose3,Cal3_S2>(f,pose,K);
@@ -82,7 +82,7 @@ TEST(PinholeCamera, Pose) {
 
   // Check derivative
   std::function<Pose3(Camera)> f =  //
-      std::bind(&Camera::getPose, std::placeholders::_1, boost::none);
+      std::bind(&Camera::getPose, std::placeholders::_1, nullptr);
   Matrix numericalH = numericalDerivative11<Pose3,Camera>(f,camera);
   EXPECT(assert_equal(numericalH, actualH, 1e-9));
 }
diff --git a/gtsam/geometry/tests/testPinholePose.cpp b/gtsam/geometry/tests/testPinholePose.cpp
index acfcd9f39..4fccc18a1 100644
--- a/gtsam/geometry/tests/testPinholePose.cpp
+++ b/gtsam/geometry/tests/testPinholePose.cpp
@@ -66,7 +66,7 @@ TEST(PinholeCamera, Pose) {
 
   // Check derivative
   std::function<Pose3(Camera)> f = //
-      std::bind(&Camera::getPose,_1,boost::none);
+      std::bind(&Camera::getPose,_1,{});
   Matrix numericalH = numericalDerivative11<Pose3,Camera>(f,camera);
   EXPECT(assert_equal(numericalH, actualH, 1e-9));
 }
diff --git a/gtsam/geometry/tests/testPoint3.cpp b/gtsam/geometry/tests/testPoint3.cpp
index e373e1d52..ad9f29620 100644
--- a/gtsam/geometry/tests/testPoint3.cpp
+++ b/gtsam/geometry/tests/testPoint3.cpp
@@ -121,9 +121,8 @@ TEST( Point3, dot) {
 /* ************************************************************************* */
 TEST(Point3, cross) {
   Matrix aH1, aH2;
-  std::function<Point3(const Point3&, const Point3&)> f =
-      std::bind(&gtsam::cross, std::placeholders::_1, std::placeholders::_2,
-                boost::none, boost::none);
+  std::function<Point3(const Point3&, const Point3&)> f = 
+    [](const Point3& p, const Point3& q) { return gtsam::cross(p, q); };
   const Point3 omega(0, 1, 0), theta(4, 6, 8);
   cross(omega, theta, aH1, aH2);
   EXPECT(assert_equal(numericalDerivative21(f, omega, theta), aH1));
@@ -142,8 +141,7 @@ TEST( Point3, cross2) {
   // Use numerical derivatives to calculate the expected Jacobians
   Matrix H1, H2;
   std::function<Point3(const Point3&, const Point3&)> f =
-      std::bind(&gtsam::cross, std::placeholders::_1, std::placeholders::_2,  //
-                boost::none, boost::none);
+    [](const Point3& p, const Point3& q) { return gtsam::cross(p, q); };
   {
     gtsam::cross(p, q, H1, H2);
     EXPECT(assert_equal(numericalDerivative21<Point3,Point3>(f, p, q), H1, 1e-9));
@@ -162,8 +160,8 @@ TEST (Point3, normalize) {
   Point3 point(1, -2, 3); // arbitrary point
   Point3 expected(point / sqrt(14.0));
   EXPECT(assert_equal(expected, normalize(point, actualH), 1e-8));
-  Matrix expectedH = numericalDerivative11<Point3, Point3>(
-      std::bind(gtsam::normalize, std::placeholders::_1, boost::none), point);
+  std::function<Point3(const Point3&)> fn = [](const Point3& p) { return normalize(p); };
+  Matrix expectedH = numericalDerivative11<Point3, Point3>(fn, point);
   EXPECT(assert_equal(expectedH, actualH, 1e-8));
 }
 
diff --git a/gtsam/geometry/tests/testPose2.cpp b/gtsam/geometry/tests/testPose2.cpp
index 44dc55a81..e38bfbd75 100644
--- a/gtsam/geometry/tests/testPose2.cpp
+++ b/gtsam/geometry/tests/testPose2.cpp
@@ -23,7 +23,7 @@
 #include <gtsam/geometry/Pose2.h>
 #include <gtsam/geometry/Rot2.h>
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <cmath>
 #include <iostream>
 
@@ -228,7 +228,7 @@ TEST( Pose2, ExpmapDerivative1) {
   Vector3 w(0.1, 0.27, -0.3);
   Pose2::Expmap(w,actualH);
   Matrix3 expectedH = numericalDerivative21<Pose2, Vector3,
-      OptionalJacobian<3, 3> >(&Pose2::Expmap, w, boost::none, 1e-2);
+      OptionalJacobian<3, 3> >(&Pose2::Expmap, w, {}, 1e-2);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
@@ -238,7 +238,7 @@ TEST( Pose2, ExpmapDerivative2) {
   Vector3 w0(0.1, 0.27, 0.0);  // alpha = 0
   Pose2::Expmap(w0,actualH);
   Matrix3 expectedH = numericalDerivative21<Pose2, Vector3,
-      OptionalJacobian<3, 3> >(&Pose2::Expmap, w0, boost::none, 1e-2);
+      OptionalJacobian<3, 3> >(&Pose2::Expmap, w0, {}, 1e-2);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
@@ -249,7 +249,7 @@ TEST( Pose2, LogmapDerivative1) {
   Pose2 p = Pose2::Expmap(w);
   EXPECT(assert_equal(w, Pose2::Logmap(p,actualH), 1e-5));
   Matrix3 expectedH = numericalDerivative21<Vector3, Pose2,
-      OptionalJacobian<3, 3> >(&Pose2::Logmap, p, boost::none, 1e-2);
+      OptionalJacobian<3, 3> >(&Pose2::Logmap, p, {}, 1e-2);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
@@ -260,7 +260,7 @@ TEST( Pose2, LogmapDerivative2) {
   Pose2 p = Pose2::Expmap(w0);
   EXPECT(assert_equal(w0, Pose2::Logmap(p,actualH), 1e-5));
   Matrix3 expectedH = numericalDerivative21<Vector3, Pose2,
-      OptionalJacobian<3, 3> >(&Pose2::Logmap, p, boost::none, 1e-2);
+      OptionalJacobian<3, 3> >(&Pose2::Logmap, p, {}, 1e-2);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
@@ -718,7 +718,7 @@ TEST(Pose2, align_1) {
   Pose2 expected(Rot2::fromAngle(0), Point2(10, 10));
   Point2Pairs ab_pairs {{Point2(10, 10), Point2(0, 0)},
                         {Point2(30, 20), Point2(20, 10)}};
-  boost::optional<Pose2> aTb = Pose2::Align(ab_pairs);
+  std::optional<Pose2> aTb = Pose2::Align(ab_pairs);
   EXPECT(assert_equal(expected, *aTb));
 }
 
@@ -731,7 +731,7 @@ TEST(Pose2, align_2) {
   Point2Pairs ab_pairs {{expected.transformFrom(b1), b1},
                         {expected.transformFrom(b2), b2}};
 
-  boost::optional<Pose2> aTb = Pose2::Align(ab_pairs);
+  std::optional<Pose2> aTb = Pose2::Align(ab_pairs);
   EXPECT(assert_equal(expected, *aTb));
 }
 
@@ -752,7 +752,7 @@ TEST(Pose2, align_3) {
   Point2Pair ab3(make_pair(a3, b3));
   const Point2Pairs ab_pairs{ab1, ab2, ab3};
 
-  boost::optional<Pose2> aTb = Pose2::Align(ab_pairs);
+  std::optional<Pose2> aTb = Pose2::Align(ab_pairs);
   EXPECT(assert_equal(expected, *aTb));
 }
 
@@ -762,7 +762,7 @@ namespace {
   /* ************************************************************************* */
   struct Triangle { size_t i_, j_, k_;};
 
-  boost::optional<Pose2> align2(const Point2Vector& as, const Point2Vector& bs,
+  std::optional<Pose2> align2(const Point2Vector& as, const Point2Vector& bs,
     const pair<Triangle, Triangle>& trianglePair) {
       const Triangle& t1 = trianglePair.first, t2 = trianglePair.second;
       Point2Pairs ab_pairs = {{as[t1.i_], bs[t2.i_]},
@@ -780,7 +780,7 @@ TEST(Pose2, align_4) {
   Triangle t1; t1.i_=0; t1.j_=1; t1.k_=2;
   Triangle t2; t2.i_=1; t2.j_=2; t2.k_=0;
 
-  boost::optional<Pose2> actual = align2(as, bs, {t1, t2});
+  std::optional<Pose2> actual = align2(as, bs, {t1, t2});
   EXPECT(assert_equal(expected, *actual));
 }
 
diff --git a/gtsam/geometry/tests/testPose3.cpp b/gtsam/geometry/tests/testPose3.cpp
index dd7da172e..93cf99972 100644
--- a/gtsam/geometry/tests/testPose3.cpp
+++ b/gtsam/geometry/tests/testPose3.cpp
@@ -23,6 +23,7 @@
 
 #include <CppUnitLite/TestHarness.h>
 #include <cmath>
+#include <functional>
 
 using namespace std;
 using namespace gtsam;
@@ -286,8 +287,8 @@ TEST(Pose3, translation) {
   Matrix actualH;
   EXPECT(assert_equal(Point3(3.5, -8.2, 4.2), T.translation(actualH), 1e-8));
 
-  Matrix numericalH = numericalDerivative11<Point3, Pose3>(
-      std::bind(&Pose3::translation, std::placeholders::_1, boost::none), T);
+  std::function<Point3(const Pose3&)> f = [](const Pose3& T) { return T.translation(); };
+  Matrix numericalH = numericalDerivative11<Point3, Pose3>(f, T);
   EXPECT(assert_equal(numericalH, actualH, 1e-6));
 }
 
@@ -297,8 +298,8 @@ TEST(Pose3, rotation) {
   Matrix actualH;
   EXPECT(assert_equal(R, T.rotation(actualH), 1e-8));
 
-  Matrix numericalH = numericalDerivative11<Rot3, Pose3>(
-      std::bind(&Pose3::rotation, std::placeholders::_1, boost::none), T);
+  std::function<Rot3(const Pose3&)> f = [](const Pose3& T) { return T.rotation(); };
+  Matrix numericalH = numericalDerivative11<Rot3, Pose3>(f, T);
   EXPECT(assert_equal(numericalH, actualH, 1e-6));
 }
 
@@ -396,7 +397,7 @@ Point3 transformFrom_(const Pose3& pose, const Point3& point) {
 }
 TEST(Pose3, Dtransform_from1_a) {
   Matrix actualDtransform_from1;
-  T.transformFrom(P, actualDtransform_from1, boost::none);
+  T.transformFrom(P, actualDtransform_from1, {});
   Matrix numerical = numericalDerivative21(transformFrom_, T, P);
   EXPECT(assert_equal(numerical, actualDtransform_from1, 1e-8));
 }
@@ -404,7 +405,7 @@ TEST(Pose3, Dtransform_from1_a) {
 TEST(Pose3, Dtransform_from1_b) {
   Pose3 origin;
   Matrix actualDtransform_from1;
-  origin.transformFrom(P, actualDtransform_from1, boost::none);
+  origin.transformFrom(P, actualDtransform_from1, {});
   Matrix numerical = numericalDerivative21(transformFrom_, origin, P);
   EXPECT(assert_equal(numerical, actualDtransform_from1, 1e-8));
 }
@@ -413,7 +414,7 @@ TEST(Pose3, Dtransform_from1_c) {
   Point3 origin(0, 0, 0);
   Pose3 T0(R, origin);
   Matrix actualDtransform_from1;
-  T0.transformFrom(P, actualDtransform_from1, boost::none);
+  T0.transformFrom(P, actualDtransform_from1, {});
   Matrix numerical = numericalDerivative21(transformFrom_, T0, P);
   EXPECT(assert_equal(numerical, actualDtransform_from1, 1e-8));
 }
@@ -423,7 +424,7 @@ TEST(Pose3, Dtransform_from1_d) {
   Point3 t0(100, 0, 0);
   Pose3 T0(I, t0);
   Matrix actualDtransform_from1;
-  T0.transformFrom(P, actualDtransform_from1, boost::none);
+  T0.transformFrom(P, actualDtransform_from1, {});
   // print(computed, "Dtransform_from1_d computed:");
   Matrix numerical = numericalDerivative21(transformFrom_, T0, P);
   // print(numerical, "Dtransform_from1_d numerical:");
@@ -433,7 +434,7 @@ TEST(Pose3, Dtransform_from1_d) {
 /* ************************************************************************* */
 TEST(Pose3, Dtransform_from2) {
   Matrix actualDtransform_from2;
-  T.transformFrom(P, boost::none, actualDtransform_from2);
+  T.transformFrom(P, {}, actualDtransform_from2);
   Matrix numerical = numericalDerivative22(transformFrom_, T, P);
   EXPECT(assert_equal(numerical, actualDtransform_from2, 1e-8));
 }
@@ -444,7 +445,7 @@ Point3 transform_to_(const Pose3& pose, const Point3& point) {
 }
 TEST(Pose3, Dtransform_to1) {
   Matrix computed;
-  T.transformTo(P, computed, boost::none);
+  T.transformTo(P, computed, {});
   Matrix numerical = numericalDerivative21(transform_to_, T, P);
   EXPECT(assert_equal(numerical, computed, 1e-8));
 }
@@ -452,7 +453,7 @@ TEST(Pose3, Dtransform_to1) {
 /* ************************************************************************* */
 TEST(Pose3, Dtransform_to2) {
   Matrix computed;
-  T.transformTo(P, boost::none, computed);
+  T.transformTo(P, {}, computed);
   Matrix numerical = numericalDerivative22(transform_to_, T, P);
   EXPECT(assert_equal(numerical, computed, 1e-8));
 }
@@ -812,7 +813,7 @@ TEST(Pose3, Align1) {
   Point3Pair ab3(Point3(20,30,0), Point3(10,20,0));
   const vector<Point3Pair> correspondences{ab1, ab2, ab3};
 
-  boost::optional<Pose3> actual = Pose3::Align(correspondences);
+  std::optional<Pose3> actual = Pose3::Align(correspondences);
   EXPECT(assert_equal(expected, *actual));
 }
 
@@ -829,7 +830,7 @@ TEST(Pose3, Align2) {
   const Point3Pair ab1{q1, p1}, ab2{q2, p2}, ab3{q3, p3};
   const vector<Point3Pair> correspondences{ab1, ab2, ab3};
 
-  boost::optional<Pose3> actual = Pose3::Align(correspondences);
+  std::optional<Pose3> actual = Pose3::Align(correspondences);
   EXPECT(assert_equal(expected, *actual, 1e-5));
 }
 
@@ -839,7 +840,7 @@ TEST( Pose3, ExpmapDerivative1) {
   Vector6 w; w << 0.1, 0.2, 0.3, 4.0, 5.0, 6.0;
   Pose3::Expmap(w,actualH);
   Matrix expectedH = numericalDerivative21<Pose3, Vector6,
-      OptionalJacobian<6, 6> >(&Pose3::Expmap, w, boost::none);
+      OptionalJacobian<6, 6> >(&Pose3::Expmap, w, {});
   EXPECT(assert_equal(expectedH, actualH));
 }
 
@@ -884,7 +885,7 @@ TEST( Pose3, ExpmapDerivativeQr) {
   w.head<3>() = w.head<3>() * 0.9e-2;
   Matrix3 actualQr = Pose3::ComputeQforExpmapDerivative(w, 0.01);
   Matrix expectedH = numericalDerivative21<Pose3, Vector6,
-      OptionalJacobian<6, 6> >(&Pose3::Expmap, w, boost::none);
+      OptionalJacobian<6, 6> >(&Pose3::Expmap, w, {});
   Matrix3 expectedQr = expectedH.bottomLeftCorner<3, 3>();
   EXPECT(assert_equal(expectedQr, actualQr, 1e-6));
 }
@@ -896,7 +897,7 @@ TEST( Pose3, LogmapDerivative) {
   Pose3 p = Pose3::Expmap(w);
   EXPECT(assert_equal(w, Pose3::Logmap(p,actualH), 1e-5));
   Matrix expectedH = numericalDerivative21<Vector6, Pose3,
-      OptionalJacobian<6, 6> >(&Pose3::Logmap, p, boost::none);
+      OptionalJacobian<6, 6> >(&Pose3::Logmap, p, {});
   EXPECT(assert_equal(expectedH, actualH));
 }
 
@@ -1189,9 +1190,9 @@ TEST(Pose3, Create) {
   Matrix63 actualH1, actualH2;
   Pose3 actual = Pose3::Create(R, P2, actualH1, actualH2);
   EXPECT(assert_equal(T, actual));
-  std::function<Pose3(Rot3, Point3)> create =
-      std::bind(Pose3::Create, std::placeholders::_1, std::placeholders::_2,
-                boost::none, boost::none);
+  std::function<Pose3(Rot3, Point3)> create = [](Rot3 R, Point3 t) {
+    return Pose3::Create(R, t);
+  };
   EXPECT(assert_equal(numericalDerivative21<Pose3,Rot3,Point3>(create, R, P2), actualH1, 1e-9));
   EXPECT(assert_equal(numericalDerivative22<Pose3,Rot3,Point3>(create, R, P2), actualH2, 1e-9));
 }
diff --git a/gtsam/geometry/tests/testRot3.cpp b/gtsam/geometry/tests/testRot3.cpp
index 1df342d57..0e7967715 100644
--- a/gtsam/geometry/tests/testRot3.cpp
+++ b/gtsam/geometry/tests/testRot3.cpp
@@ -360,7 +360,7 @@ TEST( Rot3, rotate_derivatives)
 {
   Matrix actualDrotate1a, actualDrotate1b, actualDrotate2;
   R.rotate(P, actualDrotate1a, actualDrotate2);
-  R.inverse().rotate(P, actualDrotate1b, boost::none);
+  R.inverse().rotate(P, actualDrotate1b, {});
   Matrix numerical1 = numericalDerivative21(testing::rotate<Rot3,Point3>, R, P);
   Matrix numerical2 = numericalDerivative21(testing::rotate<Rot3,Point3>, R.inverse(), P);
   Matrix numerical3 = numericalDerivative22(testing::rotate<Rot3,Point3>, R, P);
diff --git a/gtsam/geometry/tests/testRot3Q.cpp b/gtsam/geometry/tests/testRot3Q.cpp
index be159ed58..94f216828 100644
--- a/gtsam/geometry/tests/testRot3Q.cpp
+++ b/gtsam/geometry/tests/testRot3Q.cpp
@@ -1,4 +1,4 @@
-/* ----------------------------------------------------------------------------
+/* ------------------------------------------------------------------
 
  * GTSAM Copyright 2010, Georgia Tech Research Corporation,
  * Atlanta, Georgia 30332-0415
@@ -30,7 +30,6 @@ using namespace gtsam;
 
 //******************************************************************************
 TEST(Rot3Q , Compare) {
-  using boost::none;
 
   // We set up expected values with quaternions
   typedef Quaternion Q;
@@ -47,8 +46,8 @@ TEST(Rot3Q , Compare) {
   R R1(q1), R2(q2);
 
   // Check Compose
-  Q q3 = TQ::Compose(q1, q2, none, none);
-  R R3 = TR::Compose(R1, R2, none, none);
+  Q q3 = TQ::Compose(q1, q2, {}, {});
+  R R3 = TR::Compose(R1, R2, {}, {});
   EXPECT(assert_equal(R(q3), R3));
 
   // Check Retract
@@ -86,8 +85,8 @@ TEST(Rot3Q , Compare) {
 
   // Check Compose Derivatives
   Matrix HQ, HR;
-  HQ = numericalDerivative42<Q, Q, Q, OJ, OJ>(TQ::Compose, q1, q2, none, none);
-  HR = numericalDerivative42<R, R, R, OJ, OJ>(TR::Compose, R1, R2, none, none);
+  HQ = numericalDerivative42<Q, Q, Q, OJ, OJ>(TQ::Compose, q1, q2, {}, {});
+  HR = numericalDerivative42<R, R, R, OJ, OJ>(TR::Compose, R1, R2, {}, {});
   EXPECT(assert_equal(HQ, HR));
 
 }
diff --git a/gtsam/geometry/tests/testSO3.cpp b/gtsam/geometry/tests/testSO3.cpp
index 96c1cce32..1afe9ff21 100644
--- a/gtsam/geometry/tests/testSO3.cpp
+++ b/gtsam/geometry/tests/testSO3.cpp
@@ -210,7 +210,7 @@ TEST(SO3, ExpmapDerivative) {
 TEST(SO3, ExpmapDerivative2) {
   const Vector3 theta(0.1, 0, 0.1);
   const Matrix Jexpected = numericalDerivative11<SO3, Vector3>(
-      std::bind(&SO3::Expmap, std::placeholders::_1, boost::none), theta);
+      std::bind(&SO3::Expmap, std::placeholders::_1, nullptr), theta);
 
   CHECK(assert_equal(Jexpected, SO3::ExpmapDerivative(theta)));
   CHECK(assert_equal(Matrix3(Jexpected.transpose()),
@@ -221,7 +221,7 @@ TEST(SO3, ExpmapDerivative2) {
 TEST(SO3, ExpmapDerivative3) {
   const Vector3 theta(10, 20, 30);
   const Matrix Jexpected = numericalDerivative11<SO3, Vector3>(
-      std::bind(&SO3::Expmap, std::placeholders::_1, boost::none), theta);
+      std::bind(&SO3::Expmap, std::placeholders::_1, nullptr), theta);
 
   CHECK(assert_equal(Jexpected, SO3::ExpmapDerivative(theta)));
   CHECK(assert_equal(Matrix3(Jexpected.transpose()),
@@ -276,7 +276,7 @@ TEST(SO3, ExpmapDerivative5) {
 TEST(SO3, ExpmapDerivative6) {
   const Vector3 thetahat(0.1, 0, 0.1);
   const Matrix Jexpected = numericalDerivative11<SO3, Vector3>(
-      std::bind(&SO3::Expmap, std::placeholders::_1, boost::none), thetahat);
+      std::bind(&SO3::Expmap, std::placeholders::_1, nullptr), thetahat);
   Matrix3 Jactual;
   SO3::Expmap(thetahat, Jactual);
   EXPECT(assert_equal(Jexpected, Jactual));
@@ -287,7 +287,7 @@ TEST(SO3, LogmapDerivative) {
   const Vector3 thetahat(0.1, 0, 0.1);
   const SO3 R = SO3::Expmap(thetahat);  // some rotation
   const Matrix Jexpected = numericalDerivative11<Vector, SO3>(
-      std::bind(&SO3::Logmap, std::placeholders::_1, boost::none), R);
+      std::bind(&SO3::Logmap, std::placeholders::_1, nullptr), R);
   const Matrix3 Jactual = SO3::LogmapDerivative(thetahat);
   EXPECT(assert_equal(Jexpected, Jactual));
 }
@@ -297,7 +297,7 @@ TEST(SO3, JacobianLogmap) {
   const Vector3 thetahat(0.1, 0, 0.1);
   const SO3 R = SO3::Expmap(thetahat);  // some rotation
   const Matrix Jexpected = numericalDerivative11<Vector, SO3>(
-      std::bind(&SO3::Logmap, std::placeholders::_1, boost::none), R);
+      std::bind(&SO3::Logmap, std::placeholders::_1, nullptr), R);
   Matrix3 Jactual;
   SO3::Logmap(R, Jactual);
   EXPECT(assert_equal(Jexpected, Jactual));
diff --git a/gtsam/geometry/tests/testStereoCamera.cpp b/gtsam/geometry/tests/testStereoCamera.cpp
index bc432cad3..d23b3c740 100644
--- a/gtsam/geometry/tests/testStereoCamera.cpp
+++ b/gtsam/geometry/tests/testStereoCamera.cpp
@@ -96,11 +96,11 @@ static StereoPoint2 project3(const Pose3& pose, const Point3& point, const Cal3_
 TEST( StereoCamera, Dproject)
 {
   Matrix expected1 = numericalDerivative31(project3, camPose, landmark, *K);
-  Matrix actual1; stereoCam.project2(landmark, actual1, boost::none);
+  Matrix actual1; stereoCam.project2(landmark, actual1, {});
   CHECK(assert_equal(expected1,actual1,1e-7));
 
   Matrix expected2 = numericalDerivative32(project3, camPose, landmark, *K);
-  Matrix actual2; stereoCam.project2(landmark, boost::none, actual2);
+  Matrix actual2; stereoCam.project2(landmark, {}, actual2);
   CHECK(assert_equal(expected2,actual2,1e-7));
 }
 
diff --git a/gtsam/geometry/tests/testTriangulation.cpp b/gtsam/geometry/tests/testTriangulation.cpp
index 95397d5b3..89b320e94 100644
--- a/gtsam/geometry/tests/testTriangulation.cpp
+++ b/gtsam/geometry/tests/testTriangulation.cpp
@@ -67,13 +67,13 @@ TEST(triangulation, twoPoses) {
 
   // 1. Test simple DLT, perfect in no noise situation
   bool optimize = false;
-  boost::optional<Point3> actual1 =  //
+  std::optional<Point3> actual1 =  //
       triangulatePoint3<Cal3_S2>(kPoses, kSharedCal, measurements, rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual1, 1e-7));
 
   // 2. test with optimization on, same answer
   optimize = true;
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3_S2>(kPoses, kSharedCal, measurements, rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-7));
 
@@ -82,13 +82,13 @@ TEST(triangulation, twoPoses) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
   optimize = false;
-  boost::optional<Point3> actual3 =  //
+  std::optional<Point3> actual3 =  //
       triangulatePoint3<Cal3_S2>(kPoses, kSharedCal, measurements, rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual3, 1e-4));
 
   // 4. Now with optimization on
   optimize = true;
-  boost::optional<Point3> actual4 =  //
+  std::optional<Point3> actual4 =  //
       triangulatePoint3<Cal3_S2>(kPoses, kSharedCal, measurements, rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual4, 1e-4));
 }
@@ -103,7 +103,7 @@ TEST(triangulation, twoCamerasUsingLOST) {
   double rank_tol = 1e-9;
 
   // 1. Test simple triangulation, perfect in no noise situation
-  boost::optional<Point3> actual1 =  //
+  std::optional<Point3> actual1 =  //
       triangulatePoint3<PinholeCamera<Cal3_S2>>(cameras, measurements, rank_tol,
                                                 /*optimize=*/false,
                                                 measurementNoise,
@@ -114,7 +114,7 @@ TEST(triangulation, twoCamerasUsingLOST) {
   // 0.499167, 1.19814)
   measurements[0] += Point2(0.1, 0.5);
   measurements[1] += Point2(-0.2, 0.3);
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<PinholeCamera<Cal3_S2>>(
           cameras, measurements, rank_tol,
           /*optimize=*/false, measurementNoise,
@@ -140,7 +140,7 @@ TEST(triangulation, twoCamerasLOSTvsDLT) {
   const double rank_tol = 1e-9;
   SharedNoiseModel measurementNoise = noiseModel::Isotropic::Sigma(2, 1e-2);
 
-  boost::optional<Point3> estimateLOST =  //
+  std::optional<Point3> estimateLOST =  //
       triangulatePoint3<PinholeCamera<Cal3_S2>>(cameras, measurements, rank_tol,
                                                 /*optimize=*/false,
                                                 measurementNoise,
@@ -149,7 +149,7 @@ TEST(triangulation, twoCamerasLOSTvsDLT) {
   // These values are from a MATLAB implementation.
   EXPECT(assert_equal(Point3(0.007, 0.011, 0.945), *estimateLOST, 1e-3));
 
-  boost::optional<Point3> estimateDLT =
+  std::optional<Point3> estimateDLT =
       triangulatePoint3<Cal3_S2>(cameras, measurements, rank_tol, false);
 
   // The LOST estimate should have a smaller error.
@@ -177,14 +177,14 @@ TEST(triangulation, twoPosesCal3DS2) {
 
   // 1. Test simple DLT, perfect in no noise situation
   bool optimize = false;
-  boost::optional<Point3> actual1 =  //
+  std::optional<Point3> actual1 =  //
       triangulatePoint3<Cal3DS2>(kPoses, sharedDistortedCal, measurements,
                                  rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual1, 1e-7));
 
   // 2. test with optimization on, same answer
   optimize = true;
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3DS2>(kPoses, sharedDistortedCal, measurements,
                                  rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-7));
@@ -194,14 +194,14 @@ TEST(triangulation, twoPosesCal3DS2) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
   optimize = false;
-  boost::optional<Point3> actual3 =  //
+  std::optional<Point3> actual3 =  //
       triangulatePoint3<Cal3DS2>(kPoses, sharedDistortedCal, measurements,
                                  rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual3, 1e-3));
 
   // 4. Now with optimization on
   optimize = true;
-  boost::optional<Point3> actual4 =  //
+  std::optional<Point3> actual4 =  //
       triangulatePoint3<Cal3DS2>(kPoses, sharedDistortedCal, measurements,
                                  rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual4, 1e-3));
@@ -230,14 +230,14 @@ TEST(triangulation, twoPosesFisheye) {
 
   // 1. Test simple DLT, perfect in no noise situation
   bool optimize = false;
-  boost::optional<Point3> actual1 =  //
+  std::optional<Point3> actual1 =  //
       triangulatePoint3<Calibration>(kPoses, sharedDistortedCal, measurements,
                                      rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual1, 1e-7));
 
   // 2. test with optimization on, same answer
   optimize = true;
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Calibration>(kPoses, sharedDistortedCal, measurements,
                                      rank_tol, optimize);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-7));
@@ -247,14 +247,14 @@ TEST(triangulation, twoPosesFisheye) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
   optimize = false;
-  boost::optional<Point3> actual3 =  //
+  std::optional<Point3> actual3 =  //
       triangulatePoint3<Calibration>(kPoses, sharedDistortedCal, measurements,
                                      rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual3, 1e-3));
 
   // 4. Now with optimization on
   optimize = true;
-  boost::optional<Point3> actual4 =  //
+  std::optional<Point3> actual4 =  //
       triangulatePoint3<Calibration>(kPoses, sharedDistortedCal, measurements,
                                      rank_tol, optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19814), *actual4, 1e-3));
@@ -277,7 +277,7 @@ TEST(triangulation, twoPosesBundler) {
   bool optimize = true;
   double rank_tol = 1e-9;
 
-  boost::optional<Point3> actual =  //
+  std::optional<Point3> actual =  //
       triangulatePoint3<Cal3Bundler>(kPoses, bundlerCal, measurements, rank_tol,
                                      optimize);
   EXPECT(assert_equal(kLandmark, *actual, 1e-7));
@@ -286,7 +286,7 @@ TEST(triangulation, twoPosesBundler) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
 
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3Bundler>(kPoses, bundlerCal, measurements, rank_tol,
                                      optimize);
   EXPECT(assert_equal(Point3(4.995, 0.499167, 1.19847), *actual2, 1e-3));
@@ -296,7 +296,7 @@ TEST(triangulation, twoPosesBundler) {
 TEST(triangulation, fourPoses) {
   Pose3Vector poses = kPoses;
   Point2Vector measurements = kMeasurements;
-  boost::optional<Point3> actual =
+  std::optional<Point3> actual =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   EXPECT(assert_equal(kLandmark, *actual, 1e-2));
 
@@ -305,7 +305,7 @@ TEST(triangulation, fourPoses) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
 
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-2));
 
@@ -317,12 +317,12 @@ TEST(triangulation, fourPoses) {
   poses.push_back(pose3);
   measurements.push_back(z3 + Point2(0.1, -0.1));
 
-  boost::optional<Point3> triangulated_3cameras =  //
+  std::optional<Point3> triangulated_3cameras =  //
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   EXPECT(assert_equal(kLandmark, *triangulated_3cameras, 1e-2));
 
   // Again with nonlinear optimization
-  boost::optional<Point3> triangulated_3cameras_opt =
+  std::optional<Point3> triangulated_3cameras_opt =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements, 1e-9, true);
   EXPECT(assert_equal(kLandmark, *triangulated_3cameras_opt, 1e-2));
 
@@ -352,7 +352,7 @@ TEST(triangulation, threePoses_robustNoiseModel) {
   Point2Vector measurements{kZ1, kZ2, z3};
 
   // noise free, so should give exactly the landmark
-  boost::optional<Point3> actual =
+  std::optional<Point3> actual =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   EXPECT(assert_equal(kLandmark, *actual, 1e-2));
 
@@ -360,14 +360,14 @@ TEST(triangulation, threePoses_robustNoiseModel) {
   measurements.at(0) += Point2(100, 120); // very large pixel noise!
 
   // now estimate does not match landmark
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   // DLT is surprisingly robust, but still off (actual error is around 0.26m):
   EXPECT( (kLandmark - *actual2).norm() >= 0.2);
   EXPECT( (kLandmark - *actual2).norm() <= 0.5);
 
   // Again with nonlinear optimization
-  boost::optional<Point3> actual3 =
+  std::optional<Point3> actual3 =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements, 1e-9, true);
   // result from nonlinear (but non-robust optimization) is close to DLT and still off
   EXPECT(assert_equal(*actual2, *actual3, 0.1));
@@ -375,7 +375,7 @@ TEST(triangulation, threePoses_robustNoiseModel) {
   // Again with nonlinear optimization, this time with robust loss
   auto model = noiseModel::Robust::Create(
         noiseModel::mEstimator::Huber::Create(1.345), noiseModel::Unit::Create(2));
-  boost::optional<Point3> actual4 = triangulatePoint3<Cal3_S2>(
+  std::optional<Point3> actual4 = triangulatePoint3<Cal3_S2>(
       poses, kSharedCal, measurements, 1e-9, true, model);
   // using the Huber loss we now have a quite small error!! nice!
   EXPECT(assert_equal(kLandmark, *actual4, 0.05));
@@ -393,7 +393,7 @@ TEST(triangulation, fourPoses_robustNoiseModel) {
   Point2Vector measurements{kZ1, kZ1, kZ2, z3};
 
   // noise free, so should give exactly the landmark
-  boost::optional<Point3> actual =
+  std::optional<Point3> actual =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   EXPECT(assert_equal(kLandmark, *actual, 1e-2));
 
@@ -405,14 +405,14 @@ TEST(triangulation, fourPoses_robustNoiseModel) {
   measurements.at(3) += Point2(0.3, 0.1);
 
   // now estimate does not match landmark
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements);
   // DLT is surprisingly robust, but still off (actual error is around 0.17m):
   EXPECT( (kLandmark - *actual2).norm() >= 0.1);
   EXPECT( (kLandmark - *actual2).norm() <= 0.5);
 
   // Again with nonlinear optimization
-  boost::optional<Point3> actual3 =
+  std::optional<Point3> actual3 =
       triangulatePoint3<Cal3_S2>(poses, kSharedCal, measurements, 1e-9, true);
   // result from nonlinear (but non-robust optimization) is close to DLT and still off
   EXPECT(assert_equal(*actual2, *actual3, 0.1));
@@ -420,7 +420,7 @@ TEST(triangulation, fourPoses_robustNoiseModel) {
   // Again with nonlinear optimization, this time with robust loss
   auto model = noiseModel::Robust::Create(
         noiseModel::mEstimator::Huber::Create(1.345), noiseModel::Unit::Create(2));
-  boost::optional<Point3> actual4 = triangulatePoint3<Cal3_S2>(
+  std::optional<Point3> actual4 = triangulatePoint3<Cal3_S2>(
       poses, kSharedCal, measurements, 1e-9, true, model);
   // using the Huber loss we now have a quite small error!! nice!
   EXPECT(assert_equal(kLandmark, *actual4, 0.05));
@@ -443,7 +443,7 @@ TEST(triangulation, fourPoses_distinct_Ks) {
   CameraSet<PinholeCamera<Cal3_S2>> cameras{camera1, camera2};
   Point2Vector measurements{z1, z2};
 
-  boost::optional<Point3> actual =  //
+  std::optional<Point3> actual =  //
       triangulatePoint3<Cal3_S2>(cameras, measurements);
   EXPECT(assert_equal(kLandmark, *actual, 1e-2));
 
@@ -452,7 +452,7 @@ TEST(triangulation, fourPoses_distinct_Ks) {
   measurements.at(0) += Point2(0.1, 0.5);
   measurements.at(1) += Point2(-0.2, 0.3);
 
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<Cal3_S2>(cameras, measurements);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-2));
 
@@ -465,12 +465,12 @@ TEST(triangulation, fourPoses_distinct_Ks) {
   cameras.push_back(camera3);
   measurements.push_back(z3 + Point2(0.1, -0.1));
 
-  boost::optional<Point3> triangulated_3cameras =  //
+  std::optional<Point3> triangulated_3cameras =  //
       triangulatePoint3<Cal3_S2>(cameras, measurements);
   EXPECT(assert_equal(kLandmark, *triangulated_3cameras, 1e-2));
 
   // Again with nonlinear optimization
-  boost::optional<Point3> triangulated_3cameras_opt =
+  std::optional<Point3> triangulated_3cameras_opt =
       triangulatePoint3<Cal3_S2>(cameras, measurements, 1e-9, true);
   EXPECT(assert_equal(kLandmark, *triangulated_3cameras_opt, 1e-2));
 
@@ -506,7 +506,7 @@ TEST(triangulation, fourPoses_distinct_Ks_distortion) {
   const CameraSet<PinholeCamera<Cal3DS2>> cameras{camera1, camera2};
   const Point2Vector measurements{z1, z2};
 
-  boost::optional<Point3> actual =  //
+  std::optional<Point3> actual =  //
           triangulatePoint3<Cal3DS2>(cameras, measurements);
   EXPECT(assert_equal(kLandmark, *actual, 1e-2));
 }
@@ -727,14 +727,14 @@ TEST(triangulation, twoPoses_sphericalCamera) {
 
   // 3. Test simple DLT, now within triangulatePoint3
   bool optimize = false;
-  boost::optional<Point3> actual1 =  //
+  std::optional<Point3> actual1 =  //
       triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                          optimize);
   EXPECT(assert_equal(kLandmark, *actual1, 1e-7));
 
   // 4. test with optimization on, same answer
   optimize = true;
-  boost::optional<Point3> actual2 =  //
+  std::optional<Point3> actual2 =  //
       triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                          optimize);
   EXPECT(assert_equal(kLandmark, *actual2, 1e-7));
@@ -745,14 +745,14 @@ TEST(triangulation, twoPoses_sphericalCamera) {
       u1.retract(Vector2(0.01, 0.05));  // note: perturbation smaller for Unit3
   measurements.at(1) = u2.retract(Vector2(-0.02, 0.03));
   optimize = false;
-  boost::optional<Point3> actual3 =  //
+  std::optional<Point3> actual3 =  //
       triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                          optimize);
   EXPECT(assert_equal(Point3(5.9432, 0.654319, 1.48192), *actual3, 1e-3));
 
   // 6. Now with optimization on
   optimize = true;
-  boost::optional<Point3> actual4 =  //
+  std::optional<Point3> actual4 =  //
       triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                          optimize);
   EXPECT(assert_equal(Point3(5.9432, 0.654334, 1.48192), *actual4, 1e-3));
@@ -795,7 +795,7 @@ TEST(triangulation, twoPoses_sphericalCamera_extremeFOV) {
                                                        rank_tol, optimize),
                     TriangulationCheiralityException);
 #else  // otherwise project should not throw the exception
-    boost::optional<Point3> actual1 =  //
+    std::optional<Point3> actual1 =  //
         triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                            optimize);
     EXPECT(assert_equal(landmarkL, *actual1, 1e-7));
@@ -809,7 +809,7 @@ TEST(triangulation, twoPoses_sphericalCamera_extremeFOV) {
                                                        rank_tol, optimize),
                     TriangulationCheiralityException);
 #else  // otherwise project should not throw the exception
-    boost::optional<Point3> actual1 =  //
+    std::optional<Point3> actual1 =  //
         triangulatePoint3<SphericalCamera>(cameras, measurements, rank_tol,
                                            optimize);
     EXPECT(assert_equal(landmarkL, *actual1, 1e-7));
diff --git a/gtsam/geometry/tests/testUnit3.cpp b/gtsam/geometry/tests/testUnit3.cpp
index 96a5522fb..29d4aee5e 100644
--- a/gtsam/geometry/tests/testUnit3.cpp
+++ b/gtsam/geometry/tests/testUnit3.cpp
@@ -74,12 +74,12 @@ TEST(Unit3, rotate) {
   // Use numerical derivatives to calculate the expected Jacobian
   {
     expectedH = numericalDerivative21(rotate_, R, p);
-    R.rotate(p, actualH, boost::none);
+    R.rotate(p, actualH, {});
     EXPECT(assert_equal(expectedH, actualH, 1e-5));
   }
   {
     expectedH = numericalDerivative22(rotate_, R, p);
-    R.rotate(p, boost::none, actualH);
+    R.rotate(p, {}, actualH);
     EXPECT(assert_equal(expectedH, actualH, 1e-5));
   }
 }
@@ -100,12 +100,12 @@ TEST(Unit3, unrotate) {
   // Use numerical derivatives to calculate the expected Jacobian
   {
     expectedH = numericalDerivative21(unrotate_, R, p);
-    R.unrotate(p, actualH, boost::none);
+    R.unrotate(p, actualH, {});
     EXPECT(assert_equal(expectedH, actualH, 1e-5));
   }
   {
     expectedH = numericalDerivative22(unrotate_, R, p);
-    R.unrotate(p, boost::none, actualH);
+    R.unrotate(p, {}, actualH);
     EXPECT(assert_equal(expectedH, actualH, 1e-5));
   }
 }
@@ -124,7 +124,7 @@ TEST(Unit3, dot) {
   Matrix H1, H2;
   std::function<double(const Unit3&, const Unit3&)> f =
       std::bind(&Unit3::dot, std::placeholders::_1, std::placeholders::_2,  //
-                boost::none, boost::none);
+                nullptr, nullptr);
   {
     p.dot(q, H1, H2);
     EXPECT(assert_equal(numericalDerivative21<double,Unit3>(f, p, q), H1, 1e-5));
@@ -154,13 +154,13 @@ TEST(Unit3, error) {
   // Use numerical derivatives to calculate the expected Jacobian
   {
     expected = numericalDerivative11<Vector2,Unit3>(
-        std::bind(&Unit3::error, &p, std::placeholders::_1, boost::none), q);
+        std::bind(&Unit3::error, &p, std::placeholders::_1, nullptr), q);
     p.error(q, actual);
     EXPECT(assert_equal(expected.transpose(), actual, 1e-5));
   }
   {
     expected = numericalDerivative11<Vector2,Unit3>(
-        std::bind(&Unit3::error, &p, std::placeholders::_1, boost::none), r);
+        std::bind(&Unit3::error, &p, std::placeholders::_1, nullptr), r);
     p.error(r, actual);
     EXPECT(assert_equal(expected.transpose(), actual, 1e-5));
   }
@@ -182,33 +182,33 @@ TEST(Unit3, error2) {
   {
     expected = numericalDerivative21<Vector2, Unit3, Unit3>(
         std::bind(&Unit3::errorVector, std::placeholders::_1,
-                  std::placeholders::_2, boost::none, boost::none),
+                  std::placeholders::_2, nullptr, nullptr),
         p, q);
-    p.errorVector(q, actual, boost::none);
+    p.errorVector(q, actual, {});
     EXPECT(assert_equal(expected, actual, 1e-5));
   }
   {
     expected = numericalDerivative21<Vector2, Unit3, Unit3>(
         std::bind(&Unit3::errorVector, std::placeholders::_1,
-                  std::placeholders::_2, boost::none, boost::none),
+                  std::placeholders::_2, nullptr, nullptr),
         p, r);
-    p.errorVector(r, actual, boost::none);
+    p.errorVector(r, actual, {});
     EXPECT(assert_equal(expected, actual, 1e-5));
   }
   {
     expected = numericalDerivative22<Vector2, Unit3, Unit3>(
         std::bind(&Unit3::errorVector, std::placeholders::_1,
-                  std::placeholders::_2, boost::none, boost::none),
+                  std::placeholders::_2, nullptr, nullptr),
         p, q);
-    p.errorVector(q, boost::none, actual);
+    p.errorVector(q, {}, actual);
     EXPECT(assert_equal(expected, actual, 1e-5));
   }
   {
     expected = numericalDerivative22<Vector2, Unit3, Unit3>(
         std::bind(&Unit3::errorVector, std::placeholders::_1,
-                  std::placeholders::_2, boost::none, boost::none),
+                  std::placeholders::_2, nullptr, nullptr),
         p, r);
-    p.errorVector(r, boost::none, actual);
+    p.errorVector(r, {}, actual);
     EXPECT(assert_equal(expected, actual, 1e-5));
   }
 }
@@ -225,13 +225,13 @@ TEST(Unit3, distance) {
   // Use numerical derivatives to calculate the expected Jacobian
   {
     expected = numericalGradient<Unit3>(
-        std::bind(&Unit3::distance, &p, std::placeholders::_1, boost::none), q);
+        std::bind(&Unit3::distance, &p, std::placeholders::_1, nullptr), q);
     p.distance(q, actual);
     EXPECT(assert_equal(expected.transpose(), actual, 1e-5));
   }
   {
     expected = numericalGradient<Unit3>(
-        std::bind(&Unit3::distance, &p, std::placeholders::_1, boost::none), r);
+        std::bind(&Unit3::distance, &p, std::placeholders::_1, nullptr), r);
     p.distance(r, actual);
     EXPECT(assert_equal(expected.transpose(), actual, 1e-5));
   }
@@ -323,7 +323,7 @@ TEST(Unit3, basis) {
 
   Matrix62 actualH;
   Matrix62 expectedH = numericalDerivative11<Vector6, Unit3>(
-      std::bind(BasisTest, std::placeholders::_1, boost::none), p);
+      std::bind(BasisTest, std::placeholders::_1, nullptr), p);
 
   // without H, first time
   EXPECT(assert_equal(expected, p.basis(), 1e-6));
@@ -352,7 +352,7 @@ TEST(Unit3, basis_derivatives) {
     p.basis(actualH);
 
     Matrix62 expectedH = numericalDerivative11<Vector6, Unit3>(
-        std::bind(BasisTest, std::placeholders::_1, boost::none), p);
+        std::bind(BasisTest, std::placeholders::_1, nullptr), p);
     EXPECT(assert_equal(expectedH, actualH, 1e-5));
   }
 }
@@ -381,7 +381,7 @@ TEST (Unit3, jacobian_retract) {
   Matrix22 H;
   Unit3 p;
   std::function<Unit3(const Vector2&)> f =
-      std::bind(&Unit3::retract, p, std::placeholders::_1, boost::none);
+      std::bind(&Unit3::retract, p, std::placeholders::_1, nullptr);
   {
       Vector2 v (-0.2, 0.1);
       p.retract(v, H);
@@ -444,7 +444,7 @@ TEST (Unit3, FromPoint3) {
   Unit3 expected(point);
   EXPECT(assert_equal(expected, Unit3::FromPoint3(point, actualH), 1e-5));
   Matrix expectedH = numericalDerivative11<Unit3, Point3>(
-      std::bind(Unit3::FromPoint3, std::placeholders::_1, boost::none), point);
+      std::bind(Unit3::FromPoint3, std::placeholders::_1, nullptr), point);
   EXPECT(assert_equal(expectedH, actualH, 1e-5));
 }
 
diff --git a/gtsam/geometry/triangulation.h b/gtsam/geometry/triangulation.h
index e0473f8c3..f0810105f 100644
--- a/gtsam/geometry/triangulation.h
+++ b/gtsam/geometry/triangulation.h
@@ -20,6 +20,7 @@
 
 #pragma once
 
+#include "gtsam/geometry/Point3.h"
 #include <gtsam/geometry/Cal3Bundler.h>
 #include <gtsam/geometry/Cal3Fisheye.h>
 #include <gtsam/geometry/Cal3Unified.h>
@@ -33,6 +34,8 @@
 #include <gtsam/nonlinear/NonlinearFactorGraph.h>
 #include <gtsam/slam/TriangulationFactor.h>
 
+#include <optional>
+
 namespace gtsam {
 
 /// Exception thrown by triangulateDLT when SVD returns rank < 3
@@ -260,7 +263,7 @@ Cal3_S2 createPinholeCalibration(const CALIBRATION& cal) {
 template <class CALIBRATION, class MEASUREMENT>
 MEASUREMENT undistortMeasurementInternal(
     const CALIBRATION& cal, const MEASUREMENT& measurement,
-    boost::optional<Cal3_S2> pinholeCal = boost::none) {
+    std::optional<Cal3_S2> pinholeCal = {}) {
   if (!pinholeCal) {
     pinholeCal = createPinholeCalibration(cal);
   }
@@ -623,7 +626,7 @@ private:
  * TriangulationResult is an optional point, along with the reasons why it is
  * invalid.
  */
-class TriangulationResult : public boost::optional<Point3> {
+class TriangulationResult : public std::optional<Point3> {
  public:
   enum Status { VALID, DEGENERATE, BEHIND_CAMERA, OUTLIER, FAR_POINT };
   Status status;
@@ -640,7 +643,7 @@ class TriangulationResult : public boost::optional<Point3> {
   /**
    * Constructor
    */
-  TriangulationResult(const Point3& p) : status(VALID) { reset(p); }
+  TriangulationResult(const Point3& p) : status(VALID) { emplace(p); }
   static TriangulationResult Degenerate() {
     return TriangulationResult(DEGENERATE);
   }
@@ -656,6 +659,10 @@ class TriangulationResult : public boost::optional<Point3> {
   bool outlier() const { return status == OUTLIER; }
   bool farPoint() const { return status == FAR_POINT; }
   bool behindCamera() const { return status == BEHIND_CAMERA; }
+  const gtsam::Point3& get() const {
+    if (!has_value()) throw std::runtime_error("TriangulationResult has no value");
+    return value();
+  }
   // stream to output
   friend std::ostream& operator<<(std::ostream& os,
                                   const TriangulationResult& result) {
diff --git a/gtsam/hybrid/HybridGaussianFactorGraph.h b/gtsam/hybrid/HybridGaussianFactorGraph.h
index 0db4f734b..b516d0adc 100644
--- a/gtsam/hybrid/HybridGaussianFactorGraph.h
+++ b/gtsam/hybrid/HybridGaussianFactorGraph.h
@@ -27,6 +27,9 @@
 #include <gtsam/linear/GaussianFactor.h>
 #include <gtsam/linear/VectorValues.h>
 
+#include <functional>
+#include <optional>
+
 namespace gtsam {
 
 // Forward declarations
@@ -85,7 +88,7 @@ struct EliminationTraits<HybridGaussianFactorGraph> {
   /// The default ordering generation function
   static Ordering DefaultOrderingFunc(
       const FactorGraphType& graph,
-      boost::optional<const VariableIndex&> variableIndex) {
+      std::optional<std::reference_wrapper<const VariableIndex>>) {
     return HybridOrdering(graph);
   }
 };
diff --git a/gtsam/hybrid/HybridGaussianISAM.cpp b/gtsam/hybrid/HybridGaussianISAM.cpp
index 3f63cb089..dc7746209 100644
--- a/gtsam/hybrid/HybridGaussianISAM.cpp
+++ b/gtsam/hybrid/HybridGaussianISAM.cpp
@@ -71,8 +71,8 @@ Ordering HybridGaussianISAM::GetOrdering(
 void HybridGaussianISAM::updateInternal(
     const HybridGaussianFactorGraph& newFactors,
     HybridBayesTree::Cliques* orphans,
-    const boost::optional<size_t>& maxNrLeaves,
-    const boost::optional<Ordering>& ordering,
+    const std::optional<size_t>& maxNrLeaves,
+    const std::optional<Ordering>& ordering,
     const HybridBayesTree::Eliminate& function) {
   // Remove the contaminated part of the Bayes tree
   BayesNetType bn;
@@ -102,7 +102,7 @@ void HybridGaussianISAM::updateInternal(
 
   // eliminate all factors (top, added, orphans) into a new Bayes tree
   HybridBayesTree::shared_ptr bayesTree =
-      factors.eliminateMultifrontal(elimination_ordering, function, index);
+      factors.eliminateMultifrontal(elimination_ordering, function, std::cref(index));
 
   if (maxNrLeaves) {
     bayesTree->prune(*maxNrLeaves);
@@ -116,8 +116,8 @@ void HybridGaussianISAM::updateInternal(
 
 /* ************************************************************************* */
 void HybridGaussianISAM::update(const HybridGaussianFactorGraph& newFactors,
-                                const boost::optional<size_t>& maxNrLeaves,
-                                const boost::optional<Ordering>& ordering,
+                                const std::optional<size_t>& maxNrLeaves,
+                                const std::optional<Ordering>& ordering,
                                 const HybridBayesTree::Eliminate& function) {
   Cliques orphans;
   this->updateInternal(newFactors, &orphans, maxNrLeaves, ordering, function);
diff --git a/gtsam/hybrid/HybridGaussianISAM.h b/gtsam/hybrid/HybridGaussianISAM.h
index 5e936c47b..b353b26a3 100644
--- a/gtsam/hybrid/HybridGaussianISAM.h
+++ b/gtsam/hybrid/HybridGaussianISAM.h
@@ -24,6 +24,8 @@
 #include <gtsam/hybrid/HybridGaussianFactorGraph.h>
 #include <gtsam/inference/ISAM.h>
 
+#include <optional>
+
 namespace gtsam {
 
 /**
@@ -53,8 +55,8 @@ class GTSAM_EXPORT HybridGaussianISAM : public ISAM<HybridBayesTree> {
   void updateInternal(
       const HybridGaussianFactorGraph& newFactors,
       HybridBayesTree::Cliques* orphans,
-      const boost::optional<size_t>& maxNrLeaves = boost::none,
-      const boost::optional<Ordering>& ordering = boost::none,
+      const std::optional<size_t>& maxNrLeaves = {},
+      const std::optional<Ordering>& ordering = {},
       const HybridBayesTree::Eliminate& function =
           HybridBayesTree::EliminationTraitsType::DefaultEliminate);
 
@@ -68,8 +70,8 @@ class GTSAM_EXPORT HybridGaussianISAM : public ISAM<HybridBayesTree> {
    * @param function Elimination function.
    */
   void update(const HybridGaussianFactorGraph& newFactors,
-              const boost::optional<size_t>& maxNrLeaves = boost::none,
-              const boost::optional<Ordering>& ordering = boost::none,
+              const std::optional<size_t>& maxNrLeaves = {},
+              const std::optional<Ordering>& ordering = {},
               const HybridBayesTree::Eliminate& function =
                   HybridBayesTree::EliminationTraitsType::DefaultEliminate);
 
diff --git a/gtsam/hybrid/HybridNonlinearISAM.cpp b/gtsam/hybrid/HybridNonlinearISAM.cpp
index b7a5a8eeb..9a6d25ade 100644
--- a/gtsam/hybrid/HybridNonlinearISAM.cpp
+++ b/gtsam/hybrid/HybridNonlinearISAM.cpp
@@ -34,8 +34,8 @@ void HybridNonlinearISAM::saveGraph(const string& s,
 /* ************************************************************************* */
 void HybridNonlinearISAM::update(const HybridNonlinearFactorGraph& newFactors,
                                  const Values& initialValues,
-                                 const boost::optional<size_t>& maxNrLeaves,
-                                 const boost::optional<Ordering>& ordering) {
+                                 const std::optional<size_t>& maxNrLeaves,
+                                 const std::optional<Ordering>& ordering) {
   if (newFactors.size() > 0) {
     // Reorder and relinearize every reorderInterval updates
     if (reorderInterval_ > 0 && ++reorderCounter_ >= reorderInterval_) {
@@ -70,7 +70,7 @@ void HybridNonlinearISAM::reorder_relinearize() {
     // Just recreate the whole BayesTree
     // TODO: allow for constrained ordering here
     // TODO: decouple relinearization and reordering to avoid
-    isam_.update(*factors_.linearize(newLinPoint), boost::none, boost::none,
+    isam_.update(*factors_.linearize(newLinPoint), {}, {},
                  eliminationFunction_);
 
     // Update linearization point
diff --git a/gtsam/hybrid/HybridNonlinearISAM.h b/gtsam/hybrid/HybridNonlinearISAM.h
index 53bacb0ff..3372593be 100644
--- a/gtsam/hybrid/HybridNonlinearISAM.h
+++ b/gtsam/hybrid/HybridNonlinearISAM.h
@@ -19,6 +19,7 @@
 
 #include <gtsam/hybrid/HybridGaussianISAM.h>
 #include <gtsam/hybrid/HybridNonlinearFactorGraph.h>
+#include <optional>
 
 namespace gtsam {
 /**
@@ -119,8 +120,8 @@ class GTSAM_EXPORT HybridNonlinearISAM {
   /** Add new factors along with their initial linearization points */
   void update(const HybridNonlinearFactorGraph& newFactors,
               const Values& initialValues,
-              const boost::optional<size_t>& maxNrLeaves = boost::none,
-              const boost::optional<Ordering>& ordering = boost::none);
+              const std::optional<size_t>& maxNrLeaves = {},
+              const std::optional<Ordering>& ordering = {});
 
   /** Relinearization and reordering of variables */
   void reorder_relinearize();
diff --git a/gtsam/hybrid/HybridSmoother.cpp b/gtsam/hybrid/HybridSmoother.cpp
index 35dd5f88b..7e8a5f4d6 100644
--- a/gtsam/hybrid/HybridSmoother.cpp
+++ b/gtsam/hybrid/HybridSmoother.cpp
@@ -26,7 +26,7 @@ namespace gtsam {
 /* ************************************************************************* */
 void HybridSmoother::update(HybridGaussianFactorGraph graph,
                             const Ordering &ordering,
-                            boost::optional<size_t> maxNrLeaves) {
+                            std::optional<size_t> maxNrLeaves) {
   // Add the necessary conditionals from the previous timestep(s).
   std::tie(graph, hybridBayesNet_) =
       addConditionals(graph, hybridBayesNet_, ordering);
diff --git a/gtsam/hybrid/HybridSmoother.h b/gtsam/hybrid/HybridSmoother.h
index 7e90f9425..00dfc4685 100644
--- a/gtsam/hybrid/HybridSmoother.h
+++ b/gtsam/hybrid/HybridSmoother.h
@@ -20,6 +20,8 @@
 #include <gtsam/hybrid/HybridBayesNet.h>
 #include <gtsam/hybrid/HybridGaussianFactorGraph.h>
 
+#include <optional>
+
 namespace gtsam {
 
 class HybridSmoother {
@@ -48,7 +50,7 @@ class HybridSmoother {
    * if applicable
    */
   void update(HybridGaussianFactorGraph graph, const Ordering& ordering,
-              boost::optional<size_t> maxNrLeaves = boost::none);
+              std::optional<size_t> maxNrLeaves = {});
 
   /**
    * @brief Add conditionals from previous timestep as part of liquefication.
diff --git a/gtsam/hybrid/tests/TinyHybridExample.h b/gtsam/hybrid/tests/TinyHybridExample.h
index 0ef8955c4..39a1a1a9e 100644
--- a/gtsam/hybrid/tests/TinyHybridExample.h
+++ b/gtsam/hybrid/tests/TinyHybridExample.h
@@ -71,7 +71,7 @@ inline HybridBayesNet createHybridBayesNet(size_t num_measurements = 1,
  */
 inline HybridGaussianFactorGraph createHybridGaussianFactorGraph(
     size_t num_measurements = 1,
-    boost::optional<VectorValues> measurements = boost::none,
+    std::optional<VectorValues> measurements = {},
     bool manyModes = false) {
   auto bayesNet = createHybridBayesNet(num_measurements, manyModes);
   if (measurements) {
diff --git a/gtsam/inference/BayesTree-inst.h b/gtsam/inference/BayesTree-inst.h
index 055971a82..65ba37889 100644
--- a/gtsam/inference/BayesTree-inst.h
+++ b/gtsam/inference/BayesTree-inst.h
@@ -25,7 +25,6 @@
 #include <gtsam/base/treeTraversal-inst.h>
 #include <gtsam/base/timing.h>
 
-#include <boost/optional.hpp>
 #include <fstream>
 
 namespace gtsam {
diff --git a/gtsam/inference/BayesTreeCliqueBase-inst.h b/gtsam/inference/BayesTreeCliqueBase-inst.h
index 6da7d0fe4..37ed49055 100644
--- a/gtsam/inference/BayesTreeCliqueBase-inst.h
+++ b/gtsam/inference/BayesTreeCliqueBase-inst.h
@@ -178,7 +178,7 @@ namespace gtsam {
                            this->conditional()->endParents());
         auto separatorMarginal =
             p_Cp.marginalMultifrontalBayesNet(Ordering(indicesS), function);
-        cachedSeparatorMarginal_.reset(*separatorMarginal);
+        cachedSeparatorMarginal_ = *separatorMarginal;
       }
     }
 
@@ -217,7 +217,7 @@ namespace gtsam {
       }
 
       //Delete CachedShortcut for this clique
-      cachedSeparatorMarginal_ = boost::none;
+      cachedSeparatorMarginal_ = {};
     }
 
   }
diff --git a/gtsam/inference/BayesTreeCliqueBase.h b/gtsam/inference/BayesTreeCliqueBase.h
index c9bb6db94..4cb0941b9 100644
--- a/gtsam/inference/BayesTreeCliqueBase.h
+++ b/gtsam/inference/BayesTreeCliqueBase.h
@@ -21,10 +21,10 @@
 #include <gtsam/inference/Ordering.h>
 #include <gtsam/base/types.h>
 #include <gtsam/base/FastVector.h>
-#include <boost/optional.hpp>
 
 #include <string>
 #include <mutex>
+#include <optional>
 
 namespace gtsam {
 
@@ -102,7 +102,7 @@ namespace gtsam {
     /// @}
 
     /// This stores the Cached separator marginal P(S)
-    mutable boost::optional<FactorGraphType> cachedSeparatorMarginal_;
+    mutable std::optional<FactorGraphType> cachedSeparatorMarginal_;
     /// This protects Cached seperator marginal P(S) from concurrent read/writes
     /// as many the functions which access it are const (hence the mutable)
     /// leading to the false impression that these const functions are thread-safe
@@ -174,7 +174,7 @@ namespace gtsam {
      */
     void deleteCachedShortcuts();
 
-    const boost::optional<FactorGraphType>& cachedSeparatorMarginal() const {
+    const std::optional<FactorGraphType>& cachedSeparatorMarginal() const {
       std::lock_guard<std::mutex> marginalLock(cachedSeparatorMarginalMutex_);
       return cachedSeparatorMarginal_; 
     }
@@ -194,7 +194,7 @@ namespace gtsam {
     /** Non-recursive delete cached shortcuts and marginals - internal only. */
     void deleteCachedShortcutsNonRecursive() { 
       std::lock_guard<std::mutex> marginalLock(cachedSeparatorMarginalMutex_);
-      cachedSeparatorMarginal_ = boost::none; 
+      cachedSeparatorMarginal_ = {}; 
     }
 
   private:
diff --git a/gtsam/inference/DotWriter.cpp b/gtsam/inference/DotWriter.cpp
index eac0c90f9..8047c281f 100644
--- a/gtsam/inference/DotWriter.cpp
+++ b/gtsam/inference/DotWriter.cpp
@@ -40,7 +40,7 @@ void DotWriter::digraphPreamble(ostream* os) const {
 }
 
 void DotWriter::drawVariable(Key key, const KeyFormatter& keyFormatter,
-                             const boost::optional<Vector2>& position,
+                             const std::optional<Vector2>& position,
                              ostream* os) const {
   // Label the node with the label from the KeyFormatter
   *os << "  var" << key << "[label=\"" << keyFormatter(key)
@@ -54,7 +54,7 @@ void DotWriter::drawVariable(Key key, const KeyFormatter& keyFormatter,
   *os << "];\n";
 }
 
-void DotWriter::DrawFactor(size_t i, const boost::optional<Vector2>& position,
+void DotWriter::DrawFactor(size_t i, const std::optional<Vector2>& position,
                            ostream* os) {
   *os << "  factor" << i << "[label=\"\", shape=point";
   if (position) {
@@ -76,26 +76,28 @@ static void ConnectVariableFactor(Key key, const KeyFormatter& keyFormatter,
 }
 
 /// Return variable position or none
-boost::optional<Vector2> DotWriter::variablePos(Key key) const {
-  boost::optional<Vector2> result = boost::none;
+std::optional<Vector2> DotWriter::variablePos(Key key) const {
+  std::optional<Vector2> result = {};
 
   // Check position hint
   Symbol symbol(key);
   auto hint = positionHints.find(symbol.chr());
-  if (hint != positionHints.end())
-    result.reset(Vector2(symbol.index(), hint->second));
+  if (hint != positionHints.end()) {
+    result = Vector2(symbol.index(), hint->second);
+  }
 
   // Override with explicit position, if given.
   auto pos = variablePositions.find(key);
-  if (pos != variablePositions.end())
-    result.reset(pos->second);
+  if (pos != variablePositions.end()) {
+    result = pos->second;
+  }
 
   return result;
 }
 
 void DotWriter::processFactor(size_t i, const KeyVector& keys,
                               const KeyFormatter& keyFormatter,
-                              const boost::optional<Vector2>& position,
+                              const std::optional<Vector2>& position,
                               ostream* os) const {
   if (plotFactorPoints) {
     if (binaryEdges && keys.size() == 2) {
diff --git a/gtsam/inference/DotWriter.h b/gtsam/inference/DotWriter.h
index 4973f0e53..ff20f5fa0 100644
--- a/gtsam/inference/DotWriter.h
+++ b/gtsam/inference/DotWriter.h
@@ -25,6 +25,7 @@
 #include <iosfwd>
 #include <map>
 #include <set>
+#include <optional>
 
 namespace gtsam {
 
@@ -80,20 +81,20 @@ struct GTSAM_EXPORT DotWriter {
 
   /// Create a variable dot fragment.
   void drawVariable(Key key, const KeyFormatter& keyFormatter,
-                    const boost::optional<Vector2>& position,
+                    const std::optional<Vector2>& position,
                     std::ostream* os) const;
 
   /// Create factor dot.
-  static void DrawFactor(size_t i, const boost::optional<Vector2>& position,
+  static void DrawFactor(size_t i, const std::optional<Vector2>& position,
                          std::ostream* os);
 
   /// Return variable position or none
-  boost::optional<Vector2> variablePos(Key key) const;
+  std::optional<Vector2> variablePos(Key key) const;
 
   /// Draw a single factor, specified by its index i and its variable keys.
   void processFactor(size_t i, const KeyVector& keys,
                      const KeyFormatter& keyFormatter,
-                     const boost::optional<Vector2>& position,
+                     const std::optional<Vector2>& position,
                      std::ostream* os) const;
 };
 
diff --git a/gtsam/inference/EliminateableFactorGraph-inst.h b/gtsam/inference/EliminateableFactorGraph-inst.h
index bebce14cd..eb6d57067 100644
--- a/gtsam/inference/EliminateableFactorGraph-inst.h
+++ b/gtsam/inference/EliminateableFactorGraph-inst.h
@@ -36,7 +36,7 @@ namespace gtsam {
       // no Ordering is provided.  When removing optional from VariableIndex, create VariableIndex
       // before creating ordering.
       VariableIndex computedVariableIndex(asDerived());
-      return eliminateSequential(orderingType, function, computedVariableIndex);
+      return eliminateSequential(orderingType, function, std::cref(computedVariableIndex));
     }
     else {
       // Compute an ordering and call this function again.  We are guaranteed to have a 
@@ -45,14 +45,14 @@ namespace gtsam {
         Ordering computedOrdering = Ordering::Metis(asDerived());
         return eliminateSequential(computedOrdering, function, variableIndex);
       } else if (orderingType == Ordering::COLAMD) {
-        Ordering computedOrdering = Ordering::Colamd(*variableIndex);
+        Ordering computedOrdering = Ordering::Colamd((*variableIndex).get());
         return eliminateSequential(computedOrdering, function, variableIndex);
       } else if (orderingType == Ordering::NATURAL) {
         Ordering computedOrdering = Ordering::Natural(asDerived());
         return eliminateSequential(computedOrdering, function, variableIndex);
       } else {
         Ordering computedOrdering = EliminationTraitsType::DefaultOrderingFunc(
-            asDerived(), variableIndex);
+            asDerived(), *variableIndex);
         return eliminateSequential(computedOrdering, function, variableIndex);
       }
     }
@@ -68,11 +68,11 @@ namespace gtsam {
     if(!variableIndex) {
       // If no VariableIndex provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminateSequential(ordering, function, computedVariableIndex);
+      return eliminateSequential(ordering, function, std::cref(computedVariableIndex));
     } else {
       gttic(eliminateSequential);
       // Do elimination
-      EliminationTreeType etree(asDerived(), *variableIndex, ordering);
+      EliminationTreeType etree(asDerived(), (*variableIndex).get(), ordering);
       boost::shared_ptr<BayesNetType> bayesNet;
       boost::shared_ptr<FactorGraphType> factorGraph;
       boost::tie(bayesNet,factorGraph) = etree.eliminate(function);
@@ -99,7 +99,7 @@ namespace gtsam {
       // creating ordering.
       VariableIndex computedVariableIndex(asDerived());
       return eliminateMultifrontal(orderingType, function,
-                                   computedVariableIndex);
+                                   std::cref(computedVariableIndex));
     } else {
       // Compute an ordering and call this function again.  We are guaranteed to
       // have a VariableIndex already here because we computed one if needed in
@@ -108,14 +108,14 @@ namespace gtsam {
         Ordering computedOrdering = Ordering::Metis(asDerived());
         return eliminateMultifrontal(computedOrdering, function, variableIndex);
       } else if (orderingType == Ordering::COLAMD) {
-        Ordering computedOrdering = Ordering::Colamd(*variableIndex);
+        Ordering computedOrdering = Ordering::Colamd((*variableIndex).get());
         return eliminateMultifrontal(computedOrdering, function, variableIndex);
       } else if (orderingType == Ordering::NATURAL) {
         Ordering computedOrdering = Ordering::Natural(asDerived());
         return eliminateMultifrontal(computedOrdering, function, variableIndex);
       } else {
         Ordering computedOrdering = EliminationTraitsType::DefaultOrderingFunc(
-            asDerived(), variableIndex);
+            asDerived(), *variableIndex);
         return eliminateMultifrontal(computedOrdering, function, variableIndex);
       }
     }
@@ -131,11 +131,11 @@ namespace gtsam {
     if(!variableIndex) {
       // If no VariableIndex provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminateMultifrontal(ordering, function, computedVariableIndex);
+      return eliminateMultifrontal(ordering, function, std::cref(computedVariableIndex));
     } else {
       gttic(eliminateMultifrontal);
       // Do elimination with given ordering
-      EliminationTreeType etree(asDerived(), *variableIndex, ordering);
+      EliminationTreeType etree(asDerived(), (*variableIndex).get(), ordering);
       JunctionTreeType junctionTree(etree);
       boost::shared_ptr<BayesTreeType> bayesTree;
       boost::shared_ptr<FactorGraphType> factorGraph;
@@ -157,12 +157,12 @@ namespace gtsam {
     if(variableIndex) {
       gttic(eliminatePartialSequential);
       // Do elimination
-      EliminationTreeType etree(asDerived(), *variableIndex, ordering);
+      EliminationTreeType etree(asDerived(), (*variableIndex).get(), ordering);
       return etree.eliminate(function);
     } else {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminatePartialSequential(ordering, function, computedVariableIndex);
+      return eliminatePartialSequential(ordering, function, std::cref(computedVariableIndex));
     }
   }
 
@@ -175,7 +175,7 @@ namespace gtsam {
     if(variableIndex) {
       gttic(eliminatePartialSequential);
       // Compute full ordering
-      Ordering fullOrdering = Ordering::ColamdConstrainedFirst(*variableIndex, variables);
+      Ordering fullOrdering = Ordering::ColamdConstrainedFirst((*variableIndex).get(), variables);
 
       // Split off the part of the ordering for the variables being eliminated
       Ordering ordering(fullOrdering.begin(), fullOrdering.begin() + variables.size());
@@ -183,7 +183,7 @@ namespace gtsam {
     } else {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminatePartialSequential(variables, function, computedVariableIndex);
+      return eliminatePartialSequential(variables, function, std::cref(computedVariableIndex));
     }
   }
 
@@ -196,13 +196,13 @@ namespace gtsam {
     if(variableIndex) {
       gttic(eliminatePartialMultifrontal);
       // Do elimination
-      EliminationTreeType etree(asDerived(), *variableIndex, ordering);
+      EliminationTreeType etree(asDerived(), (*variableIndex).get(), ordering);
       JunctionTreeType junctionTree(etree);
       return junctionTree.eliminate(function);
     } else {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminatePartialMultifrontal(ordering, function, computedVariableIndex);
+      return eliminatePartialMultifrontal(ordering, function, std::cref(computedVariableIndex));
     }
   }
 
@@ -215,7 +215,7 @@ namespace gtsam {
     if(variableIndex) {
       gttic(eliminatePartialMultifrontal);
       // Compute full ordering
-      Ordering fullOrdering = Ordering::ColamdConstrainedFirst(*variableIndex, variables);
+      Ordering fullOrdering = Ordering::ColamdConstrainedFirst((*variableIndex).get(), variables);
 
       // Split off the part of the ordering for the variables being eliminated
       Ordering ordering(fullOrdering.begin(), fullOrdering.begin() + variables.size());
@@ -223,7 +223,7 @@ namespace gtsam {
     } else {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return eliminatePartialMultifrontal(variables, function, computedVariableIndex);
+      return eliminatePartialMultifrontal(variables, function, std::cref(computedVariableIndex));
     }
   }
 
@@ -237,7 +237,7 @@ namespace gtsam {
     if(!variableIndex) {
       // If no variable index is provided, compute one and call this function again
       VariableIndex index(asDerived());
-      return marginalMultifrontalBayesNet(variables, function, index);
+      return marginalMultifrontalBayesNet(variables, function, std::cref(index));
     } else {
       // No ordering was provided for the marginalized variables, so order them using constrained
       // COLAMD.
@@ -247,7 +247,7 @@ namespace gtsam {
         boost::get<const Ordering&>(&variables) : boost::get<const KeyVector&>(&variables);
 
       Ordering totalOrdering =
-        Ordering::ColamdConstrainedLast(*variableIndex, *variablesOrOrdering, unmarginalizedAreOrdered);
+        Ordering::ColamdConstrainedLast((*variableIndex).get(), *variablesOrOrdering, unmarginalizedAreOrdered);
 
       // Split up ordering
       const size_t nVars = variablesOrOrdering->size();
@@ -255,7 +255,7 @@ namespace gtsam {
       Ordering marginalVarsOrdering(totalOrdering.end() - nVars, totalOrdering.end());
 
       // Call this function again with the computed orderings
-      return marginalMultifrontalBayesNet(marginalVarsOrdering, marginalizationOrdering, function, *variableIndex);
+      return marginalMultifrontalBayesNet(marginalVarsOrdering, marginalizationOrdering, function, variableIndex);
     }
   }
 
@@ -278,7 +278,7 @@ namespace gtsam {
       boost::shared_ptr<BayesTreeType> bayesTree;
       boost::shared_ptr<FactorGraphType> factorGraph;
       boost::tie(bayesTree,factorGraph) =
-        eliminatePartialMultifrontal(marginalizedVariableOrdering, function, *variableIndex);
+        eliminatePartialMultifrontal(marginalizedVariableOrdering, function, variableIndex);
 
       if(const Ordering* varsAsOrdering = boost::get<const Ordering&>(&variables))
       {
@@ -304,7 +304,7 @@ namespace gtsam {
     if(!variableIndex) {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return marginalMultifrontalBayesTree(variables, function, computedVariableIndex);
+      return marginalMultifrontalBayesTree(variables, function, std::cref(computedVariableIndex));
     } else {
       // No ordering was provided for the marginalized variables, so order them using constrained
       // COLAMD.
@@ -314,7 +314,7 @@ namespace gtsam {
         boost::get<const Ordering&>(&variables) : boost::get<const KeyVector&>(&variables);
 
       Ordering totalOrdering =
-        Ordering::ColamdConstrainedLast(*variableIndex, *variablesOrOrdering, unmarginalizedAreOrdered);
+        Ordering::ColamdConstrainedLast((*variableIndex).get(), *variablesOrOrdering, unmarginalizedAreOrdered);
 
       // Split up ordering
       const size_t nVars = variablesOrOrdering->size();
@@ -322,7 +322,7 @@ namespace gtsam {
       Ordering marginalVarsOrdering(totalOrdering.end() - nVars, totalOrdering.end());
 
       // Call this function again with the computed orderings
-      return marginalMultifrontalBayesTree(marginalVarsOrdering, marginalizationOrdering, function, *variableIndex);
+      return marginalMultifrontalBayesTree(marginalVarsOrdering, marginalizationOrdering, function, variableIndex);
     }
   }
 
@@ -337,7 +337,7 @@ namespace gtsam {
     if(!variableIndex) {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return marginalMultifrontalBayesTree(variables, marginalizedVariableOrdering, function, computedVariableIndex);
+      return marginalMultifrontalBayesTree(variables, marginalizedVariableOrdering, function, std::cref(computedVariableIndex));
     } else {
       gttic(marginalMultifrontalBayesTree);
       // An ordering was provided for the marginalized variables, so we can first eliminate them
@@ -345,7 +345,7 @@ namespace gtsam {
       boost::shared_ptr<BayesTreeType> bayesTree;
       boost::shared_ptr<FactorGraphType> factorGraph;
       boost::tie(bayesTree,factorGraph) =
-        eliminatePartialMultifrontal(marginalizedVariableOrdering, function, *variableIndex);
+        eliminatePartialMultifrontal(marginalizedVariableOrdering, function, variableIndex);
 
       if(const Ordering* varsAsOrdering = boost::get<const Ordering&>(&variables))
       {
@@ -371,19 +371,19 @@ namespace gtsam {
     if(variableIndex)
     {
       // Compute a total ordering for all variables
-      Ordering totalOrdering = Ordering::ColamdConstrainedLast(*variableIndex, variables);
+      Ordering totalOrdering = Ordering::ColamdConstrainedLast((*variableIndex).get(), variables);
 
       // Split out the part for the marginalized variables
       Ordering marginalizationOrdering(totalOrdering.begin(), totalOrdering.end() - variables.size());
 
       // Eliminate and return the remaining factor graph
-      return eliminatePartialMultifrontal(marginalizationOrdering, function, *variableIndex).second;
+      return eliminatePartialMultifrontal(marginalizationOrdering, function, variableIndex).second;
     }
     else
     {
       // If no variable index is provided, compute one and call this function again
       VariableIndex computedVariableIndex(asDerived());
-      return marginal(variables, function, computedVariableIndex);
+      return marginal(variables, function, std::cref(computedVariableIndex));
     }
   }
 
diff --git a/gtsam/inference/EliminateableFactorGraph.h b/gtsam/inference/EliminateableFactorGraph.h
index 762912743..8cdf9abca 100644
--- a/gtsam/inference/EliminateableFactorGraph.h
+++ b/gtsam/inference/EliminateableFactorGraph.h
@@ -19,9 +19,10 @@
 #pragma once
 
 #include <boost/shared_ptr.hpp>
+#include <cstddef>
 #include <functional>
+#include <optional>
 #include <boost/variant.hpp>
-#include <boost/optional.hpp>
 
 #include <gtsam/inference/Ordering.h>
 #include <gtsam/inference/VariableIndex.h>
@@ -89,10 +90,11 @@ namespace gtsam {
     typedef std::function<EliminationResult(const FactorGraphType&, const Ordering&)> Eliminate;
 
     /// Typedef for an optional variable index as an argument to elimination functions
-    typedef boost::optional<const VariableIndex&> OptionalVariableIndex;
+    /// It is an optional to a constant reference
+    typedef std::optional<std::reference_wrapper<const VariableIndex>> OptionalVariableIndex;
 
     /// Typedef for an optional ordering type
-    typedef boost::optional<Ordering::OrderingType> OptionalOrderingType;
+    typedef std::optional<Ordering::OrderingType> OptionalOrderingType;
 
     /** Do sequential elimination of all variables to produce a Bayes net.  If an ordering is not
      *  provided, the ordering provided by COLAMD will be used.
@@ -111,13 +113,13 @@ namespace gtsam {
      *  \code
      *  VariableIndex varIndex(graph); // Build variable index
      *  Data data = otherFunctionUsingVariableIndex(graph, varIndex); // Other code that uses variable index
-     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateQR, varIndex, boost::none);
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateQR, varIndex, std::nullopt);
      *  \endcode
      *  */
     boost::shared_ptr<BayesNetType> eliminateSequential(
-      OptionalOrderingType orderingType = boost::none,
+      OptionalOrderingType orderingType = {},
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do sequential elimination of all variables to produce a Bayes net.
      *
@@ -130,13 +132,13 @@ namespace gtsam {
      *  \code
      *  VariableIndex varIndex(graph); // Build variable index
      *  Data data = otherFunctionUsingVariableIndex(graph, varIndex); // Other code that uses variable index
-     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(myOrdering, EliminateQR, varIndex, boost::none);
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(myOrdering, EliminateQR, varIndex, std::nullopt);
      *  \endcode
      *  */
     boost::shared_ptr<BayesNetType> eliminateSequential(
       const Ordering& ordering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do multifrontal elimination of all variables to produce a Bayes tree.  If an ordering is not
      *  provided, the ordering will be computed using either COLAMD or METIS, dependeing on
@@ -151,13 +153,13 @@ namespace gtsam {
      *  \code
      *  VariableIndex varIndex(graph); // Build variable index
      *  Data data = otherFunctionUsingVariableIndex(graph, varIndex); // Other code that uses variable index
-     *  boost::shared_ptr<GaussianBayesTree> result = graph.eliminateMultifrontal(EliminateQR, boost::none, varIndex);
+     *  boost::shared_ptr<GaussianBayesTree> result = graph.eliminateMultifrontal(EliminateQR, {}, varIndex);
      *  \endcode
      *  */
     boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
-      OptionalOrderingType orderingType = boost::none,
+      OptionalOrderingType orderingType = {},
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do multifrontal elimination of all variables to produce a Bayes tree.  If an ordering is not
      *  provided, the ordering will be computed using either COLAMD or METIS, dependeing on
@@ -171,7 +173,7 @@ namespace gtsam {
     boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
       const Ordering& ordering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do sequential elimination of some variables, in \c ordering provided, to produce a Bayes net
      *  and a remaining factor graph.  This computes the factorization \f$ p(X) = p(A|B) p(B) \f$,
@@ -181,7 +183,7 @@ namespace gtsam {
       eliminatePartialSequential(
       const Ordering& ordering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do sequential elimination of the given \c variables in an ordering computed by COLAMD to
      *  produce a Bayes net and a remaining factor graph.  This computes the factorization \f$ p(X)
@@ -191,7 +193,7 @@ namespace gtsam {
       eliminatePartialSequential(
       const KeyVector& variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do multifrontal elimination of some variables, in \c ordering provided, to produce a Bayes
      *  tree and a remaining factor graph.  This computes the factorization \f$ p(X) = p(A|B) p(B)
@@ -201,7 +203,7 @@ namespace gtsam {
       eliminatePartialMultifrontal(
       const Ordering& ordering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Do multifrontal elimination of the given \c variables in an ordering computed by COLAMD to
      *  produce a Bayes tree and a remaining factor graph.  This computes the factorization \f$ p(X)
@@ -211,7 +213,7 @@ namespace gtsam {
       eliminatePartialMultifrontal(
       const KeyVector& variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Compute the marginal of the requested variables and return the result as a Bayes net.  Uses
      *  COLAMD marginalization ordering by default
@@ -225,7 +227,7 @@ namespace gtsam {
     boost::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
       boost::variant<const Ordering&, const KeyVector&> variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Compute the marginal of the requested variables and return the result as a Bayes net.
      *  @param variables Determines the variables whose marginal to compute, if provided as an
@@ -241,7 +243,7 @@ namespace gtsam {
       boost::variant<const Ordering&, const KeyVector&> variables,
       const Ordering& marginalizedVariableOrdering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Compute the marginal of the requested variables and return the result as a Bayes tree.  Uses
      *  COLAMD marginalization order by default
@@ -255,7 +257,7 @@ namespace gtsam {
     boost::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
       boost::variant<const Ordering&, const KeyVector&> variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Compute the marginal of the requested variables and return the result as a Bayes tree.
      *  @param variables Determines the variables whose marginal to compute, if provided as an
@@ -271,13 +273,13 @@ namespace gtsam {
       boost::variant<const Ordering&, const KeyVector&> variables,
       const Ordering& marginalizedVariableOrdering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
     /** Compute the marginal factor graph of the requested variables. */
     boost::shared_ptr<FactorGraphType> marginal(
       const KeyVector& variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none) const;
+      OptionalVariableIndex variableIndex = {}) const;
 
   private:
 
diff --git a/gtsam/inference/FactorGraph-inst.h b/gtsam/inference/FactorGraph-inst.h
index 355fdf87e..8460bbe2c 100644
--- a/gtsam/inference/FactorGraph-inst.h
+++ b/gtsam/inference/FactorGraph-inst.h
@@ -155,7 +155,7 @@ void FactorGraph<FACTOR>::dot(std::ostream& os,
     const auto& factor = at(i);
     if (factor) {
       const KeyVector& factorKeys = factor->keys();
-      writer.processFactor(i, factorKeys, keyFormatter, boost::none, &os);
+      writer.processFactor(i, factorKeys, keyFormatter, {}, &os);
     }
   }
 
diff --git a/gtsam/inference/ISAM-inst.h b/gtsam/inference/ISAM-inst.h
index 39d840906..6026e052a 100644
--- a/gtsam/inference/ISAM-inst.h
+++ b/gtsam/inference/ISAM-inst.h
@@ -49,7 +49,7 @@ void ISAM<BAYESTREE>::updateInternal(const FactorGraphType& newFactors,
       KeyVector(newFactorKeys.begin(), newFactorKeys.end()));
 
   // eliminate all factors (top, added, orphans) into a new Bayes tree
-  auto bayesTree = factors.eliminateMultifrontal(ordering, function, index);
+  auto bayesTree = factors.eliminateMultifrontal(ordering, function, std::cref(index));
 
   // Re-add into Bayes tree data structures
   this->roots_.insert(this->roots_.end(), bayesTree->roots().begin(),
diff --git a/gtsam/inference/VariableIndex.h b/gtsam/inference/VariableIndex.h
index f934a72af..fa9944e87 100644
--- a/gtsam/inference/VariableIndex.h
+++ b/gtsam/inference/VariableIndex.h
@@ -23,11 +23,11 @@
 #include <gtsam/base/FastVector.h>
 #include <gtsam/dllexport.h>
 
-#include <boost/optional/optional.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 
 #include <cassert>
 #include <stdexcept>
+#include <optional>
 
 namespace gtsam {
 
diff --git a/gtsam/linear/AcceleratedPowerMethod.h b/gtsam/linear/AcceleratedPowerMethod.h
index daa59fc1b..795a9f329 100644
--- a/gtsam/linear/AcceleratedPowerMethod.h
+++ b/gtsam/linear/AcceleratedPowerMethod.h
@@ -60,11 +60,11 @@ class AcceleratedPowerMethod : public PowerMethod<Operator> {
    * vector as ritzVector
    */
   explicit AcceleratedPowerMethod(
-      const Operator &A, const boost::optional<Vector> initial = boost::none,
+      const Operator &A, const std::optional<Vector> initial = {},
       double initialBeta = 0.0)
       : PowerMethod<Operator>(A, initial) {
     // initialize Ritz eigen vector and previous vector
-    this->ritzVector_ = initial ? initial.get() : Vector::Random(this->dim_);
+    this->ritzVector_ = initial ? *initial : Vector::Random(this->dim_);
     this->ritzVector_.normalize();
     previousVector_ = Vector::Zero(this->dim_);
 
diff --git a/gtsam/linear/GaussianFactorGraph.h b/gtsam/linear/GaussianFactorGraph.h
index 55f8ed25d..cacb95119 100644
--- a/gtsam/linear/GaussianFactorGraph.h
+++ b/gtsam/linear/GaussianFactorGraph.h
@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <gtsam/inference/EliminateableFactorGraph.h>
 #include <gtsam/inference/FactorGraph.h>
 #include <gtsam/linear/Errors.h>  // Included here instead of fw-declared so we can use Errors::iterator
@@ -57,8 +58,8 @@ namespace gtsam {
     /// The default ordering generation function
     static Ordering DefaultOrderingFunc(
         const FactorGraphType& graph,
-        boost::optional<const VariableIndex&> variableIndex) {
-      return Ordering::Colamd(*variableIndex);
+        std::optional<std::reference_wrapper<const VariableIndex>> variableIndex) {
+      return Ordering::Colamd((*variableIndex).get());
     }
   };
 
diff --git a/gtsam/linear/IterativeSolver.h b/gtsam/linear/IterativeSolver.h
index cd3f41659..743f072f2 100644
--- a/gtsam/linear/IterativeSolver.h
+++ b/gtsam/linear/IterativeSolver.h
@@ -23,11 +23,11 @@
 
 #include <boost/tuple/tuple.hpp>
 #include <boost/shared_ptr.hpp>
-#include <boost/optional.hpp>
 
 #include <iosfwd>
 #include <string>
 #include <map>
+#include <optional>
 
 namespace gtsam {
 
diff --git a/gtsam/linear/JacobianFactor.cpp b/gtsam/linear/JacobianFactor.cpp
index 84083c4bc..6e1e7d359 100644
--- a/gtsam/linear/JacobianFactor.cpp
+++ b/gtsam/linear/JacobianFactor.cpp
@@ -264,7 +264,7 @@ void JacobianFactor::JacobianFactorHelper(const GaussianFactorGraph& graph,
   // Copy the RHS vectors and sigmas
   gttic(copy_vectors);
   bool anyConstrained = false;
-  boost::optional<Vector> sigmas;
+  std::optional<Vector> sigmas;
   // Loop over source jacobians
   DenseIndex nextRow = 0;
   for (size_t factorI = 0; factorI < jacobians.size(); ++factorI) {
diff --git a/gtsam/linear/NoiseModel.cpp b/gtsam/linear/NoiseModel.cpp
index 7108a7660..1cbbd1456 100644
--- a/gtsam/linear/NoiseModel.cpp
+++ b/gtsam/linear/NoiseModel.cpp
@@ -47,7 +47,7 @@ void updateAb(MATRIX& Ab, int j, const Vector& a, const Vector& rd) {
 
 /* ************************************************************************* */
 // check *above the diagonal* for non-zero entries
-boost::optional<Vector> checkIfDiagonal(const Matrix& M) {
+std::optional<Vector> checkIfDiagonal(const Matrix& M) {
   size_t m = M.rows(), n = M.cols();
   assert(m > 0);
   // check all non-diagonal entries
@@ -61,7 +61,7 @@ boost::optional<Vector> checkIfDiagonal(const Matrix& M) {
           break;
         }
   if (full) {
-    return boost::none;
+    return {};
   } else {
     Vector diagonal(n);
     for (j = 0; j < n; j++)
@@ -88,7 +88,7 @@ Gaussian::shared_ptr Gaussian::SqrtInformation(const Matrix& R, bool smart) {
   if (m != n)
     throw invalid_argument("Gaussian::SqrtInformation: R not square");
   if (smart) {
-    boost::optional<Vector> diagonal = checkIfDiagonal(R);
+    std::optional<Vector> diagonal = checkIfDiagonal(R);
     if (diagonal)
       return Diagonal::Sigmas(diagonal->array().inverse(), true);
   }
@@ -101,7 +101,7 @@ Gaussian::shared_ptr Gaussian::Information(const Matrix& information, bool smart
   size_t m = information.rows(), n = information.cols();
   if (m != n)
     throw invalid_argument("Gaussian::Information: R not square");
-  boost::optional<Vector> diagonal = boost::none;
+  std::optional<Vector> diagonal = {};
   if (smart)
     diagonal = checkIfDiagonal(information);
   if (diagonal)
@@ -119,7 +119,7 @@ Gaussian::shared_ptr Gaussian::Covariance(const Matrix& covariance,
   size_t m = covariance.rows(), n = covariance.cols();
   if (m != n)
     throw invalid_argument("Gaussian::Covariance: covariance not square");
-  boost::optional<Vector> variances = boost::none;
+  std::optional<Vector> variances = {};
   if (smart)
     variances = checkIfDiagonal(covariance);
   if (variances)
@@ -426,8 +426,8 @@ Constrained::shared_ptr Constrained::unit() const {
 // Check whether column a triggers a constraint and corresponding variable is deterministic
 // Return constraint_row with maximum element in case variable plays in multiple constraints
 template <typename VECTOR>
-boost::optional<size_t> check_if_constraint(VECTOR a, const Vector& invsigmas, size_t m) {
-  boost::optional<size_t> constraint_row;
+std::optional<size_t> check_if_constraint(VECTOR a, const Vector& invsigmas, size_t m) {
+  std::optional<size_t> constraint_row;
   // not zero, so roundoff errors will not be counted
   // TODO(frank): that's a fairly crude way of dealing with roundoff errors :-(
   double max_element = 1e-9;
@@ -437,7 +437,7 @@ boost::optional<size_t> check_if_constraint(VECTOR a, const Vector& invsigmas, s
     double abs_ai = std::abs(a(i,0));
     if (abs_ai > max_element) {
       max_element = abs_ai;
-      constraint_row.reset(i);
+      constraint_row = i;
     }
   }
   return constraint_row;
@@ -468,7 +468,7 @@ SharedDiagonal Constrained::QR(Matrix& Ab) const {
     Eigen::Block<Matrix> a = Ab.block(0, j, m, 1);
 
     // Check whether we need to handle as a constraint
-    boost::optional<size_t> constraint_row = check_if_constraint(a, invsigmas, m);
+    std::optional<size_t> constraint_row = check_if_constraint(a, invsigmas, m);
 
     if (constraint_row) {
       // Handle this as a constraint, as the i^th row has zero sigma with non-zero entry A(i,j)
diff --git a/gtsam/linear/NoiseModel.h b/gtsam/linear/NoiseModel.h
index 7bcf808e5..c23d35883 100644
--- a/gtsam/linear/NoiseModel.h
+++ b/gtsam/linear/NoiseModel.h
@@ -20,6 +20,7 @@
 
 #include <gtsam/base/Testable.h>
 #include <gtsam/base/Matrix.h>
+#include <gtsam/base/std_optional_serialization.h>
 #include <gtsam/dllexport.h>
 #include <gtsam/linear/LossFunctions.h>
 
@@ -27,7 +28,8 @@
 #include <boost/serialization/extended_type_info.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/serialization/shared_ptr.hpp>
-#include <boost/serialization/optional.hpp>
+
+#include <optional>
 
 namespace gtsam {
 
@@ -164,7 +166,7 @@ namespace gtsam {
     protected:
 
       /** Matrix square root of information matrix (R) */
-      boost::optional<Matrix> sqrt_information_;
+      std::optional<Matrix> sqrt_information_;
 
     private:
 
@@ -184,7 +186,7 @@ namespace gtsam {
 
       /** constructor takes square root information matrix */
       Gaussian(size_t dim = 1,
-               const boost::optional<Matrix>& sqrt_information = boost::none)
+               const std::optional<Matrix>& sqrt_information = {})
           : Base(dim), sqrt_information_(sqrt_information) {}
 
       ~Gaussian() override {}
@@ -732,7 +734,7 @@ namespace gtsam {
     };
 
     // Helper function
-    GTSAM_EXPORT boost::optional<Vector> checkIfDiagonal(const Matrix& M);
+    GTSAM_EXPORT std::optional<Vector> checkIfDiagonal(const Matrix& M);
 
   } // namespace noiseModel
 
diff --git a/gtsam/linear/PowerMethod.h b/gtsam/linear/PowerMethod.h
index 8834777cc..2c7027ebe 100644
--- a/gtsam/linear/PowerMethod.h
+++ b/gtsam/linear/PowerMethod.h
@@ -26,6 +26,7 @@
 #include <Eigen/Sparse>
 #include <random>
 #include <vector>
+#include <optional>
 
 namespace gtsam {
 
@@ -75,10 +76,10 @@ class PowerMethod {
 
   /// Construct from the aim matrix and intial ritz vector
   explicit PowerMethod(const Operator &A,
-                       const boost::optional<Vector> initial = boost::none)
+                       const std::optional<Vector> initial = {})
       : A_(A), dim_(A.rows()), nrIterations_(0) {
     Vector x0;
-    x0 = initial ? initial.get() : Vector::Random(dim_);
+    x0 = initial ? *initial : Vector::Random(dim_);
     x0.normalize();
 
     // initialize Ritz eigen value
diff --git a/gtsam/navigation/AHRSFactor.cpp b/gtsam/navigation/AHRSFactor.cpp
index f00655902..aeaff58eb 100644
--- a/gtsam/navigation/AHRSFactor.cpp
+++ b/gtsam/navigation/AHRSFactor.cpp
@@ -185,7 +185,7 @@ Rot3 AHRSFactor::Predict(const Rot3& rot_i, const Vector3& bias,
 AHRSFactor::AHRSFactor(Key rot_i, Key rot_j, Key bias,
                        const PreintegratedAhrsMeasurements& pim,
                        const Vector3& omegaCoriolis,
-                       const boost::optional<Pose3>& body_P_sensor)
+                       const std::optional<Pose3>& body_P_sensor)
     : Base(noiseModel::Gaussian::Covariance(pim.preintMeasCov_), rot_i, rot_j,
            bias),
       _PIM_(pim) {
@@ -198,7 +198,7 @@ AHRSFactor::AHRSFactor(Key rot_i, Key rot_j, Key bias,
 Rot3 AHRSFactor::predict(const Rot3& rot_i, const Vector3& bias,
                          const PreintegratedAhrsMeasurements& pim,
                          const Vector3& omegaCoriolis,
-                         const boost::optional<Pose3>& body_P_sensor) {
+                         const std::optional<Pose3>& body_P_sensor) {
   auto p = boost::make_shared<PreintegratedAhrsMeasurements::Params>(pim.p());
   p->omegaCoriolis = omegaCoriolis;
   p->body_P_sensor = body_P_sensor;
diff --git a/gtsam/navigation/AHRSFactor.h b/gtsam/navigation/AHRSFactor.h
index 3f3762682..625400a1b 100644
--- a/gtsam/navigation/AHRSFactor.h
+++ b/gtsam/navigation/AHRSFactor.h
@@ -24,6 +24,8 @@
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam/geometry/Pose3.h>
 
+#include <optional>
+
 namespace gtsam {
 
 /**
@@ -101,7 +103,7 @@ class GTSAM_EXPORT PreintegratedAhrsMeasurements : public PreintegratedRotation
 
   /// Predict bias-corrected incremental rotation
   /// TODO: The matrix Hbias is the derivative of predict? Unit-test?
-  Vector3 predict(const Vector3& bias, OptionalJacobian<3,3> H = boost::none) const;
+  Vector3 predict(const Vector3& bias, OptionalJacobian<3,3> H = {}) const;
 
   // This function is only used for test purposes
   // (compare numerical derivatives wrt analytic ones)
@@ -194,13 +196,13 @@ public:
   AHRSFactor(Key rot_i, Key rot_j, Key bias,
              const PreintegratedAhrsMeasurements& pim,
              const Vector3& omegaCoriolis,
-             const boost::optional<Pose3>& body_P_sensor = boost::none);
+             const std::optional<Pose3>& body_P_sensor = {});
 
   /// @deprecated static function, but used in tests.
   static Rot3 predict(
       const Rot3& rot_i, const Vector3& bias,
       const PreintegratedAhrsMeasurements& pim, const Vector3& omegaCoriolis,
-      const boost::optional<Pose3>& body_P_sensor = boost::none);
+      const std::optional<Pose3>& body_P_sensor = {});
 
 private:
 
diff --git a/gtsam/navigation/AttitudeFactor.h b/gtsam/navigation/AttitudeFactor.h
index e353def6a..4dc5ecc0a 100644
--- a/gtsam/navigation/AttitudeFactor.h
+++ b/gtsam/navigation/AttitudeFactor.h
@@ -54,7 +54,7 @@ public:
 
   /** vector of errors */
   Vector attitudeError(const Rot3& p,
-      OptionalJacobian<2,3> H = boost::none) const;
+      OptionalJacobian<2,3> H = {}) const;
 
   const Unit3& nZ() const {
     return nZ_;
diff --git a/gtsam/navigation/ImuBias.cpp b/gtsam/navigation/ImuBias.cpp
index bc11f95f8..49a364ca0 100644
--- a/gtsam/navigation/ImuBias.cpp
+++ b/gtsam/navigation/ImuBias.cpp
@@ -38,7 +38,7 @@ namespace imuBias {
 //    // H1: Jacobian w.r.t. IMUBias
 //    // H2: Jacobian w.r.t. pose
 //    Vector CorrectGyroWithEarthRotRate(Vector measurement, const Pose3& pose, const Vector& w_earth_rate_G,
-//        boost::optional<Matrix&> H1=boost::none, boost::optional<Matrix&> H2=boost::none) const {
+//        Matrix* H1=nullptr, Matrix* H2=nullptr) const {
 //
 //      Matrix R_G_to_I( pose.rotation().matrix().transpose() );
 //      Vector w_earth_rate_I = R_G_to_I * w_earth_rate_G;
diff --git a/gtsam/navigation/ImuBias.h b/gtsam/navigation/ImuBias.h
index 261436d2d..9e337028a 100644
--- a/gtsam/navigation/ImuBias.h
+++ b/gtsam/navigation/ImuBias.h
@@ -72,8 +72,8 @@ public:
 
   /** Correct an accelerometer measurement using this bias model, and optionally compute Jacobians */
   Vector3 correctAccelerometer(const Vector3& measurement,
-                               OptionalJacobian<3, 6> H1 = boost::none,
-                               OptionalJacobian<3, 3> H2 = boost::none) const {
+                               OptionalJacobian<3, 6> H1 = {},
+                               OptionalJacobian<3, 3> H2 = {}) const {
     if (H1) (*H1) << -I_3x3, Z_3x3;
     if (H2) (*H2) << I_3x3;
     return measurement - biasAcc_;
@@ -81,8 +81,8 @@ public:
 
   /** Correct a gyroscope measurement using this bias model, and optionally compute Jacobians */
   Vector3 correctGyroscope(const Vector3& measurement,
-                           OptionalJacobian<3, 6> H1 = boost::none,
-                           OptionalJacobian<3, 3> H2 = boost::none) const {
+                           OptionalJacobian<3, 6> H1 = {},
+                           OptionalJacobian<3, 3> H2 = {}) const {
     if (H1) (*H1) << Z_3x3, -I_3x3;
     if (H2) (*H2) << I_3x3;
     return measurement - biasGyro_;
diff --git a/gtsam/navigation/MagFactor.h b/gtsam/navigation/MagFactor.h
index 142d5a957..d0c62d6c4 100644
--- a/gtsam/navigation/MagFactor.h
+++ b/gtsam/navigation/MagFactor.h
@@ -65,7 +65,7 @@ public:
 
   static Point3 unrotate(const Rot2& R, const Point3& p,
       OptionalMatrixType HR = OptionalNone) {
-    Point3 q = Rot3::Yaw(R.theta()).unrotate(p, HR, boost::none);
+    Point3 q = Rot3::Yaw(R.theta()).unrotate(p, HR, {});
     if (HR) {
       // assign to temporary first to avoid error in Win-Debug mode
       Matrix H = HR->col(2);
diff --git a/gtsam/navigation/MagPoseFactor.h b/gtsam/navigation/MagPoseFactor.h
index d69a0e0a4..67a312af9 100644
--- a/gtsam/navigation/MagPoseFactor.h
+++ b/gtsam/navigation/MagPoseFactor.h
@@ -11,9 +11,12 @@
 
 #pragma once
 
+#include <gtsam/base/std_optional_serialization.h>
 #include <gtsam/geometry/concepts.h>
 #include <gtsam/nonlinear/NonlinearFactor.h>
 
+#include <optional>
+
 namespace gtsam {
 
 /**
@@ -35,7 +38,7 @@ class MagPoseFactor: public NoiseModelFactorN<POSE> {
   const Point measured_; ///< The measured magnetometer data in the body frame.
   const Point nM_; ///< Local magnetic field (mag output units) in the nav frame.
   const Point bias_; ///< The bias vector (mag output units) in the body frame.
-  boost::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame.
+  std::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame.
 
   static const int MeasDim = Point::RowsAtCompileTime;
   static const int PoseDim = traits<POSE>::dimension;
@@ -74,7 +77,7 @@ class MagPoseFactor: public NoiseModelFactorN<POSE> {
                 const Point& direction,
                 const Point& bias,
                 const SharedNoiseModel& model,
-                const boost::optional<POSE>& body_P_sensor)
+                const std::optional<POSE>& body_P_sensor)
       : Base(model, pose_key),
         measured_(body_P_sensor ? body_P_sensor->rotation() * measured : measured),
         nM_(scale * direction.normalized()),
diff --git a/gtsam/navigation/ManifoldPreintegration.cpp b/gtsam/navigation/ManifoldPreintegration.cpp
index 165acdaf0..baddb73e3 100644
--- a/gtsam/navigation/ManifoldPreintegration.cpp
+++ b/gtsam/navigation/ManifoldPreintegration.cpp
@@ -113,7 +113,7 @@ Vector9 ManifoldPreintegration::biasCorrectedDelta(
   const imuBias::ConstantBias biasIncr = bias_i - biasHat_;
   Matrix3 D_correctedRij_bias;
   const Vector3 biasInducedOmega = delRdelBiasOmega_ * biasIncr.gyroscope();
-  const Rot3 correctedRij = deltaRij().expmap(biasInducedOmega, boost::none,
+  const Rot3 correctedRij = deltaRij().expmap(biasInducedOmega, {},
       H ? &D_correctedRij_bias : 0);
   if (H)
     D_correctedRij_bias *= delRdelBiasOmega_;
diff --git a/gtsam/navigation/ManifoldPreintegration.h b/gtsam/navigation/ManifoldPreintegration.h
index a290972e4..b9135e3e4 100644
--- a/gtsam/navigation/ManifoldPreintegration.h
+++ b/gtsam/navigation/ManifoldPreintegration.h
@@ -103,7 +103,7 @@ public:
   /// summarizing the preintegrated IMU measurements so far
   /// NOTE(frank): implementation is different in two versions
   Vector9 biasCorrectedDelta(const imuBias::ConstantBias& bias_i,
-      OptionalJacobian<9, 6> H = boost::none) const override;
+      OptionalJacobian<9, 6> H = {}) const override;
 
   /** Dummy clone for MATLAB */
   virtual boost::shared_ptr<ManifoldPreintegration> clone() const {
diff --git a/gtsam/navigation/NavState.cpp b/gtsam/navigation/NavState.cpp
index f21a2f660..86e85a762 100644
--- a/gtsam/navigation/NavState.cpp
+++ b/gtsam/navigation/NavState.cpp
@@ -256,7 +256,7 @@ Vector9 NavState::coriolis(double dt, const Vector3& omega, bool secondOrder,
 
 //------------------------------------------------------------------------------
 Vector9 NavState::correctPIM(const Vector9& pim, double dt,
-    const Vector3& n_gravity, const boost::optional<Vector3>& omegaCoriolis,
+    const Vector3& n_gravity, const std::optional<Vector3>& omegaCoriolis,
     bool use2ndOrderCoriolis, OptionalJacobian<9, 9> H1,
     OptionalJacobian<9, 9> H2) const {
   const Rot3& nRb = R_;
diff --git a/gtsam/navigation/NavState.h b/gtsam/navigation/NavState.h
index f66e9d7a9..5e44e16c2 100644
--- a/gtsam/navigation/NavState.h
+++ b/gtsam/navigation/NavState.h
@@ -79,9 +79,9 @@ public:
   /// @name Component Access
   /// @{
 
-  const Rot3& attitude(OptionalJacobian<3, 9> H = boost::none) const;
-  const Point3& position(OptionalJacobian<3, 9> H = boost::none) const;
-  const Velocity3& velocity(OptionalJacobian<3, 9> H = boost::none) const;
+  const Rot3& attitude(OptionalJacobian<3, 9> H = {}) const;
+  const Point3& position(OptionalJacobian<3, 9> H = {}) const;
+  const Velocity3& velocity(OptionalJacobian<3, 9> H = {}) const;
 
   const Pose3 pose() const {
     return Pose3(attitude(), position());
@@ -108,7 +108,7 @@ public:
     return v_;
   }
   // Return velocity in body frame
-  Velocity3 bodyVelocity(OptionalJacobian<3, 9> H = boost::none) const;
+  Velocity3 bodyVelocity(OptionalJacobian<3, 9> H = {}) const;
 
   /// Return matrix group representation, in MATLAB notation:
   /// nTb = [nRb 0 n_t; 0 nRb n_v; 0 0 1]
@@ -156,13 +156,13 @@ public:
 
   /// retract with optional derivatives
   NavState retract(const Vector9& v, //
-      OptionalJacobian<9, 9> H1 = boost::none, OptionalJacobian<9, 9> H2 =
-          boost::none) const;
+      OptionalJacobian<9, 9> H1 = {}, OptionalJacobian<9, 9> H2 =
+          {}) const;
 
   /// localCoordinates with optional derivatives
   Vector9 localCoordinates(const NavState& g, //
-      OptionalJacobian<9, 9> H1 = boost::none, OptionalJacobian<9, 9> H2 =
-          boost::none) const;
+      OptionalJacobian<9, 9> H1 = {}, OptionalJacobian<9, 9> H2 =
+          {}) const;
 
   /// @}
   /// @name Dynamics
@@ -176,14 +176,14 @@ public:
 
   /// Compute tangent space contribution due to Coriolis forces
   Vector9 coriolis(double dt, const Vector3& omega, bool secondOrder = false,
-      OptionalJacobian<9, 9> H = boost::none) const;
+      OptionalJacobian<9, 9> H = {}) const;
 
   /// Correct preintegrated tangent vector with our velocity and rotated gravity,
   /// taking into account Coriolis forces if omegaCoriolis is given.
   Vector9 correctPIM(const Vector9& pim, double dt, const Vector3& n_gravity,
-      const boost::optional<Vector3>& omegaCoriolis, bool use2ndOrderCoriolis =
-          false, OptionalJacobian<9, 9> H1 = boost::none,
-      OptionalJacobian<9, 9> H2 = boost::none) const;
+      const std::optional<Vector3>& omegaCoriolis, bool use2ndOrderCoriolis =
+          false, OptionalJacobian<9, 9> H1 = {},
+      OptionalJacobian<9, 9> H2 = {}) const;
 
   /// @}
 
diff --git a/gtsam/navigation/PreintegratedRotation.cpp b/gtsam/navigation/PreintegratedRotation.cpp
index ee30bee9e..a9d4a28bb 100644
--- a/gtsam/navigation/PreintegratedRotation.cpp
+++ b/gtsam/navigation/PreintegratedRotation.cpp
@@ -115,8 +115,7 @@ void PreintegratedRotation::integrateMeasurement(const Vector3& measuredOmega,
 Rot3 PreintegratedRotation::biascorrectedDeltaRij(const Vector3& biasOmegaIncr,
     OptionalJacobian<3, 3> H) const {
   const Vector3 biasInducedOmega = delRdelBiasOmega_ * biasOmegaIncr;
-  const Rot3 deltaRij_biascorrected = deltaRij_.expmap(biasInducedOmega,
-      boost::none, H);
+  const Rot3 deltaRij_biascorrected = deltaRij_.expmap(biasInducedOmega,{}, H);
   if (H)
     (*H) *= delRdelBiasOmega_;
   return deltaRij_biascorrected;
diff --git a/gtsam/navigation/PreintegratedRotation.h b/gtsam/navigation/PreintegratedRotation.h
index e52d28e1e..007deeeca 100644
--- a/gtsam/navigation/PreintegratedRotation.h
+++ b/gtsam/navigation/PreintegratedRotation.h
@@ -23,6 +23,7 @@
 
 #include <gtsam/geometry/Pose3.h>
 #include <gtsam/base/Matrix.h>
+#include <gtsam/base/std_optional_serialization.h>
 
 namespace gtsam {
 
@@ -32,16 +33,17 @@ struct GTSAM_EXPORT PreintegratedRotationParams {
   /// Continuous-time "Covariance" of gyroscope measurements
   /// The units for stddev are σ = rad/s/√Hz
   Matrix3 gyroscopeCovariance;
-  boost::optional<Vector3> omegaCoriolis;  ///< Coriolis constant
-  boost::optional<Pose3> body_P_sensor;    ///< The pose of the sensor in the body frame
+  std::optional<Vector3> omegaCoriolis;  ///< Coriolis constant
+  std::optional<Pose3> body_P_sensor;    ///< The pose of the sensor in the body frame
 
   PreintegratedRotationParams() : gyroscopeCovariance(I_3x3) {}
 
   PreintegratedRotationParams(const Matrix3& gyroscope_covariance,
-                              boost::optional<Vector3> omega_coriolis)
+                              std::optional<Vector3> omega_coriolis)
     : gyroscopeCovariance(gyroscope_covariance) {
-      if (omega_coriolis)
-        omegaCoriolis.reset(omega_coriolis.get());
+      if (omega_coriolis) {
+        omegaCoriolis = *omega_coriolis;
+      }
   }
 
   virtual ~PreintegratedRotationParams() {}
@@ -50,12 +52,12 @@ struct GTSAM_EXPORT PreintegratedRotationParams {
   virtual bool equals(const PreintegratedRotationParams& other, double tol=1e-9) const;
 
   void setGyroscopeCovariance(const Matrix3& cov)   { gyroscopeCovariance = cov;  }
-  void setOmegaCoriolis(const Vector3& omega)       { omegaCoriolis.reset(omega); }
-  void setBodyPSensor(const Pose3& pose)            { body_P_sensor.reset(pose);  }
+  void setOmegaCoriolis(const Vector3& omega)       { omegaCoriolis = omega; }
+  void setBodyPSensor(const Pose3& pose)            { body_P_sensor = pose;  }
 
   const Matrix3& getGyroscopeCovariance()     const { return gyroscopeCovariance; }
-  boost::optional<Vector3> getOmegaCoriolis() const { return omegaCoriolis; }
-  boost::optional<Pose3>   getBodyPSensor()   const { return body_P_sensor; }
+  std::optional<Vector3> getOmegaCoriolis() const { return omegaCoriolis; }
+  std::optional<Pose3>   getBodyPSensor()   const { return body_P_sensor; }
 
  private:
   /** Serialization function */
@@ -66,8 +68,8 @@ struct GTSAM_EXPORT PreintegratedRotationParams {
     ar & BOOST_SERIALIZATION_NVP(gyroscopeCovariance);
     ar & BOOST_SERIALIZATION_NVP(body_P_sensor);
 
-    // Provide support for Eigen::Matrix in boost::optional
-    bool omegaCoriolisFlag = omegaCoriolis.is_initialized();
+    // Provide support for Eigen::Matrix in std::optional
+    bool omegaCoriolisFlag = omegaCoriolis.has_value();
     ar & boost::serialization::make_nvp("omegaCoriolisFlag", omegaCoriolisFlag);
     if (omegaCoriolisFlag) {
       ar & BOOST_SERIALIZATION_NVP(*omegaCoriolis);
@@ -164,12 +166,12 @@ class GTSAM_EXPORT PreintegratedRotation {
   /// Calculate an incremental rotation given the gyro measurement and a time interval,
   /// and update both deltaTij_ and deltaRij_.
   void integrateMeasurement(const Vector3& measuredOmega, const Vector3& biasHat, double deltaT,
-                            OptionalJacobian<3, 3> D_incrR_integratedOmega = boost::none,
-                            OptionalJacobian<3, 3> F = boost::none);
+                            OptionalJacobian<3, 3> D_incrR_integratedOmega = {},
+                            OptionalJacobian<3, 3> F = {});
 
   /// Return a bias corrected version of the integrated rotation, with optional Jacobian
   Rot3 biascorrectedDeltaRij(const Vector3& biasOmegaIncr,
-                             OptionalJacobian<3, 3> H = boost::none) const;
+                             OptionalJacobian<3, 3> H = {}) const;
 
   /// Integrate coriolis correction in body frame rot_i
   Vector3 integrateCoriolis(const Rot3& rot_i) const;
diff --git a/gtsam/navigation/PreintegrationBase.h b/gtsam/navigation/PreintegrationBase.h
index e118a6232..a5e9e9391 100644
--- a/gtsam/navigation/PreintegrationBase.h
+++ b/gtsam/navigation/PreintegrationBase.h
@@ -129,9 +129,9 @@ class GTSAM_EXPORT PreintegrationBase {
    */
   std::pair<Vector3, Vector3> correctMeasurementsBySensorPose(
       const Vector3& unbiasedAcc, const Vector3& unbiasedOmega,
-      OptionalJacobian<3, 3> correctedAcc_H_unbiasedAcc = boost::none,
-      OptionalJacobian<3, 3> correctedAcc_H_unbiasedOmega = boost::none,
-      OptionalJacobian<3, 3> correctedOmega_H_unbiasedOmega = boost::none) const;
+      OptionalJacobian<3, 3> correctedAcc_H_unbiasedAcc = {},
+      OptionalJacobian<3, 3> correctedAcc_H_unbiasedOmega = {},
+      OptionalJacobian<3, 3> correctedOmega_H_unbiasedOmega = {}) const;
 
   /**
    *  Update preintegrated measurements and get derivatives
@@ -148,12 +148,12 @@ class GTSAM_EXPORT PreintegrationBase {
   /// Given the estimate of the bias, return a NavState tangent vector
   /// summarizing the preintegrated IMU measurements so far
   virtual Vector9 biasCorrectedDelta(const imuBias::ConstantBias& bias_i,
-      OptionalJacobian<9, 6> H = boost::none) const = 0;
+      OptionalJacobian<9, 6> H = {}) const = 0;
 
   /// Predict state at time j
   NavState predict(const NavState& state_i, const imuBias::ConstantBias& bias_i,
-                   OptionalJacobian<9, 9> H1 = boost::none,
-                   OptionalJacobian<9, 6> H2 = boost::none) const;
+                   OptionalJacobian<9, 9> H1 = {},
+                   OptionalJacobian<9, 6> H2 = {}) const;
 
   /// Calculate error given navStates
   Vector9 computeError(const NavState& state_i, const NavState& state_j,
@@ -167,10 +167,10 @@ class GTSAM_EXPORT PreintegrationBase {
    */
   Vector9 computeErrorAndJacobians(const Pose3& pose_i, const Vector3& vel_i,
       const Pose3& pose_j, const Vector3& vel_j,
-      const imuBias::ConstantBias& bias_i, OptionalJacobian<9, 6> H1 =
-          boost::none, OptionalJacobian<9, 3> H2 = boost::none,
-      OptionalJacobian<9, 6> H3 = boost::none, OptionalJacobian<9, 3> H4 =
-          boost::none, OptionalJacobian<9, 6> H5 = boost::none) const;
+      const imuBias::ConstantBias& bias_i, 
+      OptionalJacobian<9, 6> H1 = {}, OptionalJacobian<9, 3> H2 = {},
+      OptionalJacobian<9, 6> H3 = {}, OptionalJacobian<9, 3> H4 = {}, 
+      OptionalJacobian<9, 6> H5 = {}) const;
 
  private:
   /** Serialization function */
diff --git a/gtsam/navigation/TangentPreintegration.h b/gtsam/navigation/TangentPreintegration.h
index 56b0a1c75..80a39e0f2 100644
--- a/gtsam/navigation/TangentPreintegration.h
+++ b/gtsam/navigation/TangentPreintegration.h
@@ -91,9 +91,9 @@ public:
   static Vector9 UpdatePreintegrated(const Vector3& a_body,
                                      const Vector3& w_body, const double dt,
                                      const Vector9& preintegrated,
-                                     OptionalJacobian<9, 9> A = boost::none,
-                                     OptionalJacobian<9, 3> B = boost::none,
-                                     OptionalJacobian<9, 3> C = boost::none);
+                                     OptionalJacobian<9, 9> A = {},
+                                     OptionalJacobian<9, 3> B = {},
+                                     OptionalJacobian<9, 3> C = {});
 
   /// Update preintegrated measurements and get derivatives
   /// It takes measured quantities in the j frame
@@ -106,13 +106,13 @@ public:
   /// summarizing the preintegrated IMU measurements so far
   /// NOTE(frank): implementation is different in two versions
   Vector9 biasCorrectedDelta(const imuBias::ConstantBias& bias_i,
-      OptionalJacobian<9, 6> H = boost::none) const override;
+      OptionalJacobian<9, 6> H = {}) const override;
 
   // Compose the two pre-integrated 9D-vectors zeta01 and zeta02, with derivatives
   static Vector9 Compose(const Vector9& zeta01, const Vector9& zeta12,
                          double deltaT12,
-                         OptionalJacobian<9, 9> H1 = boost::none,
-                         OptionalJacobian<9, 9> H2 = boost::none);
+                         OptionalJacobian<9, 9> H1 = {},
+                         OptionalJacobian<9, 9> H2 = {});
 
   /// Merge in a different set of measurements and update bias derivatives accordingly
   /// The derivatives apply to the preintegrated Vector9
diff --git a/gtsam/navigation/navigation.i b/gtsam/navigation/navigation.i
index 7bbef9fc5..8e6090e06 100644
--- a/gtsam/navigation/navigation.i
+++ b/gtsam/navigation/navigation.i
@@ -75,8 +75,8 @@ virtual class PreintegratedRotationParams {
 
   Matrix getGyroscopeCovariance() const;
 
-  boost::optional<Vector> getOmegaCoriolis() const;
-  boost::optional<gtsam::Pose3> getBodyPSensor() const;
+  std::optional<Vector> getOmegaCoriolis() const;
+  std::optional<gtsam::Pose3> getBodyPSensor() const;
 };
 
 #include <gtsam/navigation/PreintegrationParams.h>
diff --git a/gtsam/navigation/tests/testAHRSFactor.cpp b/gtsam/navigation/tests/testAHRSFactor.cpp
index 779f6abcc..e6a246b9c 100644
--- a/gtsam/navigation/tests/testAHRSFactor.cpp
+++ b/gtsam/navigation/tests/testAHRSFactor.cpp
@@ -140,7 +140,7 @@ TEST( AHRSFactor, PreintegratedAhrsMeasurementsConstructor ) {
   EXPECT(assert_equal(gyroscopeCovariance,
       actualPim.p().getGyroscopeCovariance(), 1e-6));
   EXPECT(assert_equal(omegaCoriolis,
-      actualPim.p().getOmegaCoriolis().get(), 1e-6));
+      *(actualPim.p().getOmegaCoriolis()), 1e-6));
   EXPECT(assert_equal(bias, actualPim.biasHat(), 1e-6));
   DOUBLES_EQUAL(deltaTij, actualPim.deltaTij(), 1e-6);
   EXPECT(assert_equal(deltaRij, Rot3(actualPim.deltaRij()), 1e-6));
@@ -163,7 +163,7 @@ TEST(AHRSFactor, Error) {
   pim.integrateMeasurement(measuredOmega, deltaT);
 
   // Create factor
-  AHRSFactor factor(X(1), X(2), B(1), pim, kZeroOmegaCoriolis, boost::none);
+  AHRSFactor factor(X(1), X(2), B(1), pim, kZeroOmegaCoriolis, {});
 
   Vector3 errorActual = factor.evaluateError(x1, x2, bias);
 
@@ -458,8 +458,7 @@ TEST (AHRSFactor, predictTest) {
 
   // PreintegratedAhrsMeasurements::predict
   Matrix expectedH = numericalDerivative11<Vector3, Vector3>(
-      std::bind(&PreintegratedAhrsMeasurements::predict,
-          &pim, std::placeholders::_1, boost::none), bias);
+      [&pim](const Vector3& b) { return pim.predict(b, {}); }, bias);
 
   // Actual Jacobians
   Matrix H;
diff --git a/gtsam/navigation/tests/testImuBias.cpp b/gtsam/navigation/tests/testImuBias.cpp
index bd6cd7234..517182f65 100644
--- a/gtsam/navigation/tests/testImuBias.cpp
+++ b/gtsam/navigation/tests/testImuBias.cpp
@@ -73,7 +73,7 @@ TEST(ImuBias, Correct1) {
   const Vector3 measurement(1, 2, 3);
   std::function<Vector3(const Bias&, const Vector3&)> f =
       std::bind(&Bias::correctAccelerometer, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+                std::placeholders::_2, nullptr, nullptr);
   bias1.correctAccelerometer(measurement, aH1, aH2);
   EXPECT(assert_equal(numericalDerivative21(f, bias1, measurement), aH1));
   EXPECT(assert_equal(numericalDerivative22(f, bias1, measurement), aH2));
@@ -85,7 +85,7 @@ TEST(ImuBias, Correct2) {
   const Vector3 measurement(1, 2, 3);
   std::function<Vector3(const Bias&, const Vector3&)> f =
       std::bind(&Bias::correctGyroscope, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+                std::placeholders::_2, nullptr, nullptr);
   bias1.correctGyroscope(measurement, aH1, aH2);
   EXPECT(assert_equal(numericalDerivative21(f, bias1, measurement), aH1));
   EXPECT(assert_equal(numericalDerivative22(f, bias1, measurement), aH2));
diff --git a/gtsam/navigation/tests/testImuFactor.cpp b/gtsam/navigation/tests/testImuFactor.cpp
index 585da38b1..923d2b93f 100644
--- a/gtsam/navigation/tests/testImuFactor.cpp
+++ b/gtsam/navigation/tests/testImuFactor.cpp
@@ -149,7 +149,7 @@ TEST(ImuFactor, PreintegratedMeasurements) {
   std::function<Vector9(const NavState&, const NavState&, const Bias&)> f =
       std::bind(&PreintegrationBase::computeError, actual,
                   std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
-                  boost::none, boost::none, boost::none);
+                  nullptr, nullptr, nullptr);
   EXPECT(assert_equal(numericalDerivative31(f, x1, x2, bias), aH1, 1e-9));
   EXPECT(assert_equal(numericalDerivative32(f, x1, x2, bias), aH2, 1e-9));
   EXPECT(assert_equal(numericalDerivative33(f, x1, x2, bias), aH3, 1e-9));
@@ -205,7 +205,7 @@ TEST(ImuFactor, PreintegrationBaseMethods) {
   pim.biasCorrectedDelta(kZeroBias, actualH);
   Matrix expectedH = numericalDerivative11<Vector9, Bias>(
       std::bind(&PreintegrationBase::biasCorrectedDelta, pim,
-          std::placeholders::_1, boost::none), kZeroBias);
+          std::placeholders::_1, nullptr), kZeroBias);
   EXPECT(assert_equal(expectedH, actualH));
 
   Matrix9 aH1;
@@ -213,11 +213,11 @@ TEST(ImuFactor, PreintegrationBaseMethods) {
   NavState predictedState = pim.predict(state1, kZeroBias, aH1, aH2);
   Matrix eH1 = numericalDerivative11<NavState, NavState>(
       std::bind(&PreintegrationBase::predict, pim, std::placeholders::_1,
-          kZeroBias, boost::none, boost::none), state1);
+          kZeroBias, nullptr, nullptr), state1);
   EXPECT(assert_equal(eH1, aH1));
   Matrix eH2 = numericalDerivative11<NavState, Bias>(
       std::bind(&PreintegrationBase::predict, pim, state1,
-          std::placeholders::_1, boost::none, boost::none), kZeroBias);
+          std::placeholders::_1, nullptr, nullptr), kZeroBias);
   EXPECT(assert_equal(eH2, aH2));
 }
 
@@ -334,7 +334,7 @@ TEST(ImuFactor, ErrorAndJacobianWithBiases) {
   pim.biasCorrectedDelta(bias, actualH);
   Matrix expectedH = numericalDerivative11<Vector9, Bias>(
       std::bind(&PreintegrationBase::biasCorrectedDelta, pim,
-          std::placeholders::_1, boost::none), bias);
+          std::placeholders::_1, nullptr), bias);
   EXPECT(assert_equal(expectedH, actualH));
 
   // Create factor
@@ -520,7 +520,7 @@ TEST(ImuFactor, ErrorWithBiasesAndSensorBodyDisplacement) {
   // Check updatedDeltaXij derivatives
   Matrix3 D_correctedAcc_measuredOmega = Z_3x3;
   pim.correctMeasurementsBySensorPose(measuredAcc, measuredOmega,
-      boost::none, D_correctedAcc_measuredOmega, boost::none);
+      nullptr, D_correctedAcc_measuredOmega, nullptr);
   Matrix3 expectedD = numericalDerivative11<Vector3, Vector3>(
       std::bind(correctedAcc, pim, measuredAcc, std::placeholders::_1),
       measuredOmega, 1e-6);
@@ -531,19 +531,19 @@ TEST(ImuFactor, ErrorWithBiasesAndSensorBodyDisplacement) {
 // TODO(frank): revive derivative tests
 //  Matrix93 G1, G2;
 //  Vector9 preint =
-//      pim.updatedDeltaXij(measuredAcc, measuredOmega, dt, boost::none, G1, G2);
+//      pim.updatedDeltaXij(measuredAcc, measuredOmega, dt, {}, G1, G2);
 //
 //  Matrix93 expectedG1 = numericalDerivative21<NavState, Vector3, Vector3>(
 //      std::bind(&PreintegratedImuMeasurements::updatedDeltaXij, pim,
 //          std::placeholders::_1, std::placeholders::_2,
-//          dt, boost::none, boost::none, boost::none), measuredAcc,
+//          dt, {}, {}, {}), measuredAcc,
 //      measuredOmega, 1e-6);
 //  EXPECT(assert_equal(expectedG1, G1, 1e-5));
 //
 //  Matrix93 expectedG2 = numericalDerivative22<NavState, Vector3, Vector3>(
 //      std::bind(&PreintegratedImuMeasurements::updatedDeltaXij, pim,
 //          std::placeholders::_1, std::placeholders::_2,
-//          dt, boost::none, boost::none, boost::none), measuredAcc,
+//          dt, {}, {}, {}), measuredAcc,
 //      measuredOmega, 1e-6);
 //  EXPECT(assert_equal(expectedG2, G2, 1e-5));
 
@@ -658,7 +658,7 @@ TEST(ImuFactor, PredictArbitrary) {
   p->integrationCovariance = Z_3x3; // MonteCarlo does not sample integration noise
   PreintegratedImuMeasurements pim(p, biasHat);
   Bias bias(Vector3(0, 0, 0), Vector3(0, 0, 0));
-//  EXPECT(MonteCarlo(pim, NavState(x1, v1), bias, 0.1, boost::none, measuredAcc, measuredOmega,
+//  EXPECT(MonteCarlo(pim, NavState(x1, v1), bias, 0.1, {}, measuredAcc, measuredOmega,
 //                    Vector3::Constant(accNoiseVar), Vector3::Constant(omegaNoiseVar), 100000));
 
   double dt = 0.001;
diff --git a/gtsam/navigation/tests/testMagPoseFactor.cpp b/gtsam/navigation/tests/testMagPoseFactor.cpp
index 9fb81cd7f..cd9c2fa49 100644
--- a/gtsam/navigation/tests/testMagPoseFactor.cpp
+++ b/gtsam/navigation/tests/testMagPoseFactor.cpp
@@ -57,8 +57,8 @@ Pose3 body_P3_sensor(Rot3::RzRyRx(Vector3(1.5, 0.9, -1.15)),
 
 // *****************************************************************************
 TEST(MagPoseFactor, Constructors) {
-  MagPoseFactor<Pose2> f2a(Symbol('X', 0), measured2, scale, dir2, bias2, model2, boost::none);
-  MagPoseFactor<Pose3> f3a(Symbol('X', 0), measured3, scale, dir3, bias3, model3, boost::none);
+  MagPoseFactor<Pose2> f2a(Symbol('X', 0), measured2, scale, dir2, bias2, model2, {});
+  MagPoseFactor<Pose3> f3a(Symbol('X', 0), measured3, scale, dir3, bias3, model3, {});
 
   // Try constructing with a body_P_sensor set.
   MagPoseFactor<Pose2> f2b = MagPoseFactor<Pose2>(
@@ -75,7 +75,7 @@ TEST(MagPoseFactor, JacobianPose2) {
   Matrix H2;
 
   // Error should be zero at the groundtruth pose.
-  MagPoseFactor<Pose2> f(Symbol('X', 0), measured2, scale, dir2, bias2, model2, boost::none);
+  MagPoseFactor<Pose2> f(Symbol('X', 0), measured2, scale, dir2, bias2, model2, {});
   CHECK(gtsam::assert_equal(Z_2x1, f.evaluateError(n_P2_b, H2), 1e-5));
   CHECK(gtsam::assert_equal(gtsam::numericalDerivative11<Vector, Pose2>  //
                             ([&f] (const Pose2& p) {return f.evaluateError(p);},
@@ -88,7 +88,7 @@ TEST(MagPoseFactor, JacobianPose3) {
   Matrix H3;
 
   // Error should be zero at the groundtruth pose.
-  MagPoseFactor<Pose3> f(Symbol('X', 0), measured3, scale, dir3, bias3, model3, boost::none);
+  MagPoseFactor<Pose3> f(Symbol('X', 0), measured3, scale, dir3, bias3, model3, {});
   CHECK(gtsam::assert_equal(Z_3x1, f.evaluateError(n_P3_b, H3), 1e-5));
   CHECK(gtsam::assert_equal(gtsam::numericalDerivative11<Vector, Pose3>  //
                             ([&f] (const Pose3& p) {return f.evaluateError(p);},
diff --git a/gtsam/navigation/tests/testManifoldPreintegration.cpp b/gtsam/navigation/tests/testManifoldPreintegration.cpp
index 7796ccbda..ba92d8e92 100644
--- a/gtsam/navigation/tests/testManifoldPreintegration.cpp
+++ b/gtsam/navigation/tests/testManifoldPreintegration.cpp
@@ -101,8 +101,8 @@ TEST(ManifoldPreintegration, computeError) {
                         const imuBias::ConstantBias&)>
       f = std::bind(&ManifoldPreintegration::computeError, pim,
                     std::placeholders::_1, std::placeholders::_2,
-                    std::placeholders::_3, boost::none, boost::none,
-                    boost::none);
+                    std::placeholders::_3, nullptr, nullptr,
+                    nullptr);
   // NOTE(frank): tolerance of 1e-3 on H1 because approximate away from 0
   EXPECT(assert_equal(numericalDerivative31(f, x1, x2, bias), aH1, 1e-9));
   EXPECT(assert_equal(numericalDerivative32(f, x1, x2, bias), aH2, 1e-9));
diff --git a/gtsam/navigation/tests/testNavState.cpp b/gtsam/navigation/tests/testNavState.cpp
index e7adb923d..e658639b0 100644
--- a/gtsam/navigation/tests/testNavState.cpp
+++ b/gtsam/navigation/tests/testNavState.cpp
@@ -41,7 +41,7 @@ static const Vector9 kZeroXi = Vector9::Zero();
 TEST(NavState, Constructor) {
   std::function<NavState(const Rot3&, const Point3&, const Vector3&)> create =
       std::bind(&NavState::Create, std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, boost::none, boost::none, boost::none);
+                std::placeholders::_3, nullptr, nullptr, nullptr);
   Matrix aH1, aH2, aH3;
   EXPECT(
       assert_equal(kState1,
@@ -61,7 +61,7 @@ TEST(NavState, Constructor) {
 TEST(NavState, Constructor2) {
   std::function<NavState(const Pose3&, const Vector3&)> construct =
       std::bind(&NavState::FromPoseVelocity, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+                std::placeholders::_2, nullptr, nullptr);
   Matrix aH1, aH2;
   EXPECT(
       assert_equal(kState1,
@@ -76,7 +76,7 @@ TEST( NavState, Attitude) {
   Rot3 actual = kState1.attitude(aH);
   EXPECT(assert_equal(actual, kAttitude));
   eH = numericalDerivative11<Rot3, NavState>(
-      std::bind(&NavState::attitude, std::placeholders::_1, boost::none), kState1);
+      std::bind(&NavState::attitude, std::placeholders::_1, nullptr), kState1);
   EXPECT(assert_equal((Matrix )eH, aH));
 }
 
@@ -86,7 +86,7 @@ TEST( NavState, Position) {
   Point3 actual = kState1.position(aH);
   EXPECT(assert_equal(actual, kPosition));
   eH = numericalDerivative11<Point3, NavState>(
-      std::bind(&NavState::position, std::placeholders::_1, boost::none),
+      std::bind(&NavState::position, std::placeholders::_1, nullptr),
       kState1);
   EXPECT(assert_equal((Matrix )eH, aH));
 }
@@ -97,7 +97,7 @@ TEST( NavState, Velocity) {
   Velocity3 actual = kState1.velocity(aH);
   EXPECT(assert_equal(actual, kVelocity));
   eH = numericalDerivative11<Velocity3, NavState>(
-      std::bind(&NavState::velocity, std::placeholders::_1, boost::none),
+      std::bind(&NavState::velocity, std::placeholders::_1, nullptr),
       kState1);
   EXPECT(assert_equal((Matrix )eH, aH));
 }
@@ -108,7 +108,7 @@ TEST( NavState, BodyVelocity) {
   Velocity3 actual = kState1.bodyVelocity(aH);
   EXPECT(assert_equal<Velocity3>(actual, kAttitude.unrotate(kVelocity)));
   eH = numericalDerivative11<Velocity3, NavState>(
-      std::bind(&NavState::bodyVelocity, std::placeholders::_1, boost::none),
+      std::bind(&NavState::bodyVelocity, std::placeholders::_1, nullptr),
       kState1);
   EXPECT(assert_equal((Matrix )eH, aH));
 }
@@ -142,7 +142,7 @@ TEST( NavState, Manifold ) {
   kState1.retract(xi, aH1, aH2);
   std::function<NavState(const NavState&, const Vector9&)> retract =
       std::bind(&NavState::retract, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+                std::placeholders::_2, nullptr, nullptr);
   EXPECT(assert_equal(numericalDerivative21(retract, kState1, xi), aH1));
   EXPECT(assert_equal(numericalDerivative22(retract, kState1, xi), aH2));
 
@@ -155,7 +155,7 @@ TEST( NavState, Manifold ) {
   // Check localCoordinates derivatives
   std::function<Vector9(const NavState&, const NavState&)> local =
       std::bind(&NavState::localCoordinates, std::placeholders::_1,
-                std::placeholders::_2, boost::none, boost::none);
+                std::placeholders::_2, nullptr, nullptr);
   // from state1 to state2
   kState1.localCoordinates(state2, aH1, aH2);
   EXPECT(assert_equal(numericalDerivative21(local, kState1, state2), aH1));
@@ -174,7 +174,7 @@ TEST( NavState, Manifold ) {
 static const double dt = 2.0;
 std::function<Vector9(const NavState&, const bool&)> coriolis =
     std::bind(&NavState::coriolis, std::placeholders::_1, dt, kOmegaCoriolis,
-              std::placeholders::_2, boost::none);
+              std::placeholders::_2, nullptr);
 
 TEST(NavState, Coriolis) {
   Matrix9 aH;
@@ -252,7 +252,7 @@ TEST(NavState, CorrectPIM) {
   std::function<Vector9(const NavState&, const Vector9&)> correctPIM =
       std::bind(&NavState::correctPIM, std::placeholders::_1,
                 std::placeholders::_2, dt, kGravity, kOmegaCoriolis, false,
-                boost::none, boost::none);
+                nullptr, nullptr);
   kState1.correctPIM(xi, dt, kGravity, kOmegaCoriolis, false, aH1, aH2);
   EXPECT(assert_equal(numericalDerivative21(correctPIM, kState1, xi), aH1));
   EXPECT(assert_equal(numericalDerivative22(correctPIM, kState1, xi), aH2));
diff --git a/gtsam/navigation/tests/testTangentPreintegration.cpp b/gtsam/navigation/tests/testTangentPreintegration.cpp
index ada059094..2f6678b97 100644
--- a/gtsam/navigation/tests/testTangentPreintegration.cpp
+++ b/gtsam/navigation/tests/testTangentPreintegration.cpp
@@ -108,8 +108,8 @@ TEST(TangentPreintegration, computeError) {
                         const imuBias::ConstantBias&)>
       f = std::bind(&TangentPreintegration::computeError, pim,
                     std::placeholders::_1, std::placeholders::_2,
-                    std::placeholders::_3, boost::none, boost::none,
-                    boost::none);
+                    std::placeholders::_3, nullptr, nullptr,
+                    nullptr);
   // NOTE(frank): tolerance of 1e-3 on H1 because approximate away from 0
   EXPECT(assert_equal(numericalDerivative31(f, x1, x2, bias), aH1, 1e-9));
   EXPECT(assert_equal(numericalDerivative32(f, x1, x2, bias), aH2, 1e-9));
diff --git a/gtsam/nonlinear/AdaptAutoDiff.h b/gtsam/nonlinear/AdaptAutoDiff.h
index 682cca29a..b616a0e63 100644
--- a/gtsam/nonlinear/AdaptAutoDiff.h
+++ b/gtsam/nonlinear/AdaptAutoDiff.h
@@ -47,8 +47,8 @@ class AdaptAutoDiff {
 
  public:
   VectorT operator()(const Vector1& v1, const Vector2& v2,
-                     OptionalJacobian<M, N1> H1 = boost::none,
-                     OptionalJacobian<M, N2> H2 = boost::none) {
+                     OptionalJacobian<M, N1> H1 = {},
+                     OptionalJacobian<M, N2> H2 = {}) {
     using ceres::internal::AutoDiff;
 
     bool success;
diff --git a/gtsam/nonlinear/Expression-inl.h b/gtsam/nonlinear/Expression-inl.h
index 06088c79b..7f7600774 100644
--- a/gtsam/nonlinear/Expression-inl.h
+++ b/gtsam/nonlinear/Expression-inl.h
@@ -241,7 +241,7 @@ struct apply_compose {
   typedef T result_type;
   static const int Dim = traits<T>::dimension;
   T operator()(const T& x, const T& y, OptionalJacobian<Dim, Dim> H1 =
-      boost::none, OptionalJacobian<Dim, Dim> H2 = boost::none) const {
+      {}, OptionalJacobian<Dim, Dim> H2 = {}) const {
     return x.compose(y, H1, H2);
   }
 };
@@ -249,8 +249,8 @@ struct apply_compose {
 template <>
 struct apply_compose<double> {
   double operator()(const double& x, const double& y,
-                    OptionalJacobian<1, 1> H1 = boost::none,
-                    OptionalJacobian<1, 1> H2 = boost::none) const {
+                    OptionalJacobian<1, 1> H1 = {},
+                    OptionalJacobian<1, 1> H2 = {}) const {
     if (H1) H1->setConstant(y);
     if (H2) H2->setConstant(x);
     return x * y;
diff --git a/gtsam/nonlinear/FunctorizedFactor.h b/gtsam/nonlinear/FunctorizedFactor.h
index 4053891f1..ee927327f 100644
--- a/gtsam/nonlinear/FunctorizedFactor.h
+++ b/gtsam/nonlinear/FunctorizedFactor.h
@@ -42,7 +42,7 @@ namespace gtsam {
  *    public:
  *     MultiplyFunctor(double m) : m_(m) {}
  *     Matrix operator()(const Matrix &X,
- *              OptionalJacobian<-1, -1> H = boost::none) const {
+ *              OptionalJacobian<-1, -1> H = {}) const {
  *       if (H)
  *         *H = m_ * Matrix::Identity(X.rows()*X.cols(), X.rows()*X.cols());
  *       return m_ * X;
diff --git a/gtsam/nonlinear/GraphvizFormatting.cpp b/gtsam/nonlinear/GraphvizFormatting.cpp
index ca3466b6a..95c6e7faa 100644
--- a/gtsam/nonlinear/GraphvizFormatting.cpp
+++ b/gtsam/nonlinear/GraphvizFormatting.cpp
@@ -34,7 +34,7 @@ Vector2 GraphvizFormatting::findBounds(const Values& values,
   min.y() = std::numeric_limits<double>::infinity();
   for (const Key& key : keys) {
     if (values.exists(key)) {
-      boost::optional<Vector2> xy = extractPosition(values.at(key));
+      std::optional<Vector2> xy = extractPosition(values.at(key));
       if (xy) {
         if (xy->x() < min.x()) min.x() = xy->x();
         if (xy->y() < min.y()) min.y() = xy->y();
@@ -44,7 +44,7 @@ Vector2 GraphvizFormatting::findBounds(const Values& values,
   return min;
 }
 
-boost::optional<Vector2> GraphvizFormatting::extractPosition(
+std::optional<Vector2> GraphvizFormatting::extractPosition(
     const Value& value) const {
   Vector3 t;
   if (const GenericValue<Pose2>* p =
@@ -62,7 +62,7 @@ boost::optional<Vector2> GraphvizFormatting::extractPosition(
       const Eigen::Ref<const Vector3> p_3d(p->value());
       t = p_3d;
     } else {
-      return boost::none;
+      return {};
     }
   } else if (const GenericValue<Pose3>* p =
                  dynamic_cast<const GenericValue<Pose3>*>(&value)) {
@@ -71,7 +71,7 @@ boost::optional<Vector2> GraphvizFormatting::extractPosition(
                  dynamic_cast<const GenericValue<Point3>*>(&value)) {
     t = p->value();
   } else {
-    return boost::none;
+    return {};
   }
   double x, y;
   switch (paperHorizontalAxis) {
@@ -121,11 +121,11 @@ boost::optional<Vector2> GraphvizFormatting::extractPosition(
   return Vector2(x, y);
 }
 
-boost::optional<Vector2> GraphvizFormatting::variablePos(const Values& values,
+std::optional<Vector2> GraphvizFormatting::variablePos(const Values& values,
                                                          const Vector2& min,
                                                          Key key) const {
   if (!values.exists(key)) return DotWriter::variablePos(key);
-  boost::optional<Vector2> xy = extractPosition(values.at(key));
+  std::optional<Vector2> xy = extractPosition(values.at(key));
   if (xy) {
     xy->x() = scale * (xy->x() - min.x());
     xy->y() = scale * (xy->y() - min.y());
@@ -133,11 +133,11 @@ boost::optional<Vector2> GraphvizFormatting::variablePos(const Values& values,
   return xy;
 }
 
-boost::optional<Vector2> GraphvizFormatting::factorPos(const Vector2& min,
+std::optional<Vector2> GraphvizFormatting::factorPos(const Vector2& min,
                                                        size_t i) const {
-  if (factorPositions.size() == 0) return boost::none;
+  if (factorPositions.size() == 0) return {};
   auto it = factorPositions.find(i);
-  if (it == factorPositions.end()) return boost::none;
+  if (it == factorPositions.end()) return {};
   auto pos = it->second;
   return Vector2(scale * (pos.x() - min.x()), scale * (pos.y() - min.y()));
 }
diff --git a/gtsam/nonlinear/GraphvizFormatting.h b/gtsam/nonlinear/GraphvizFormatting.h
index 03cdb3469..fc3cfc95e 100644
--- a/gtsam/nonlinear/GraphvizFormatting.h
+++ b/gtsam/nonlinear/GraphvizFormatting.h
@@ -53,14 +53,14 @@ struct GTSAM_EXPORT GraphvizFormatting : public DotWriter {
   Vector2 findBounds(const Values& values, const KeySet& keys) const;
 
   /// Extract a Vector2 from either Vector2, Pose2, Pose3, or Point3
-  boost::optional<Vector2> extractPosition(const Value& value) const;
+  std::optional<Vector2> extractPosition(const Value& value) const;
 
   /// Return affinely transformed variable position if it exists.
-  boost::optional<Vector2> variablePos(const Values& values, const Vector2& min,
+  std::optional<Vector2> variablePos(const Values& values, const Vector2& min,
                                        Key key) const;
 
   /// Return affinely transformed factor position if it exists.
-  boost::optional<Vector2> factorPos(const Vector2& min, size_t i) const;
+  std::optional<Vector2> factorPos(const Vector2& min, size_t i) const;
 };
 
 }  // namespace gtsam
diff --git a/gtsam/nonlinear/ISAM2-impl.h b/gtsam/nonlinear/ISAM2-impl.h
index eb2285b28..906d620cc 100644
--- a/gtsam/nonlinear/ISAM2-impl.h
+++ b/gtsam/nonlinear/ISAM2-impl.h
@@ -78,7 +78,7 @@ struct GTSAM_EXPORT DeltaImpl {
     size_t nFullSystemVars;
     enum { /*AS_ADDED,*/ COLAMD } algorithm;
     enum { NO_CONSTRAINT, CONSTRAIN_LAST } constrain;
-    boost::optional<FastMap<Key, int> > constrainedKeys;
+    std::optional<FastMap<Key, int> > constrainedKeys;
   };
 
   /**
@@ -195,9 +195,9 @@ struct GTSAM_EXPORT UpdateImpl {
 
   // Calculate nonlinear error
   void error(const NonlinearFactorGraph& nonlinearFactors,
-             const Values& estimate, boost::optional<double>* result) const {
+             const Values& estimate, std::optional<double>* result) const {
     gttic(error);
-    result->reset(nonlinearFactors.error(estimate));
+    *result = nonlinearFactors.error(estimate);
   }
 
   // Mark linear update
diff --git a/gtsam/nonlinear/ISAM2.cpp b/gtsam/nonlinear/ISAM2.cpp
index d5e25cef8..de32aea9c 100644
--- a/gtsam/nonlinear/ISAM2.cpp
+++ b/gtsam/nonlinear/ISAM2.cpp
@@ -396,9 +396,9 @@ void ISAM2::removeVariables(const KeySet& unusedKeys) {
 ISAM2Result ISAM2::update(
     const NonlinearFactorGraph& newFactors, const Values& newTheta,
     const FactorIndices& removeFactorIndices,
-    const boost::optional<FastMap<Key, int> >& constrainedKeys,
-    const boost::optional<FastList<Key> >& noRelinKeys,
-    const boost::optional<FastList<Key> >& extraReelimKeys,
+    const std::optional<FastMap<Key, int> >& constrainedKeys,
+    const std::optional<FastList<Key> >& noRelinKeys,
+    const std::optional<FastList<Key> >& extraReelimKeys,
     bool force_relinearize) {
   ISAM2UpdateParams params;
   params.constrainedKeys = constrainedKeys;
diff --git a/gtsam/nonlinear/ISAM2.h b/gtsam/nonlinear/ISAM2.h
index dd246617a..8b48f2f7d 100644
--- a/gtsam/nonlinear/ISAM2.h
+++ b/gtsam/nonlinear/ISAM2.h
@@ -87,7 +87,7 @@ class GTSAM_EXPORT ISAM2 : public BayesTree<ISAM2Clique> {
   ISAM2Params params_;
 
   /** The current Dogleg Delta (trust region radius) */
-  mutable boost::optional<double> doglegDelta_;
+  mutable std::optional<double> doglegDelta_;
 
   /** Set of variables that are involved with linear factors from marginalized
    * variables and thus cannot have their linearization points changed. */
@@ -152,9 +152,9 @@ class GTSAM_EXPORT ISAM2 : public BayesTree<ISAM2Clique> {
       const NonlinearFactorGraph& newFactors = NonlinearFactorGraph(),
       const Values& newTheta = Values(),
       const FactorIndices& removeFactorIndices = FactorIndices(),
-      const boost::optional<FastMap<Key, int> >& constrainedKeys = boost::none,
-      const boost::optional<FastList<Key> >& noRelinKeys = boost::none,
-      const boost::optional<FastList<Key> >& extraReelimKeys = boost::none,
+      const std::optional<FastMap<Key, int> >& constrainedKeys = {},
+      const std::optional<FastList<Key> >& noRelinKeys = {},
+      const std::optional<FastList<Key> >& extraReelimKeys = {},
       bool force_relinearize = false);
 
   /**
diff --git a/gtsam/nonlinear/ISAM2Result.h b/gtsam/nonlinear/ISAM2Result.h
index 077174970..26049f9da 100644
--- a/gtsam/nonlinear/ISAM2Result.h
+++ b/gtsam/nonlinear/ISAM2Result.h
@@ -51,7 +51,7 @@ struct ISAM2Result {
    * ISAM2Params::evaluateNonlinearError is set to \c true, because there is
    * some cost to this computation.
    */
-  boost::optional<double> errorBefore;
+  std::optional<double> errorBefore;
 
   /** The nonlinear error of all of the factors computed after the current
    * update, meaning that variables above the relinearization threshold
@@ -63,7 +63,7 @@ struct ISAM2Result {
    * ISAM2Params::evaluateNonlinearError is set to \c true, because there is
    * some cost to this computation.
    */
-  boost::optional<double> errorAfter;
+  std::optional<double> errorAfter;
 
   /** The number of variables that were relinearized because their linear
    * deltas exceeded the reslinearization threshold
@@ -155,14 +155,20 @@ struct ISAM2Result {
 
   /** Detailed results, if enabled by ISAM2Params::enableDetailedResults.  See
    * Detail for information about the results data stored here. */
-  boost::optional<DetailedResults> detail;
+  std::optional<DetailedResults> detail;
 
   explicit ISAM2Result(bool enableDetailedResults = false) {
-    if (enableDetailedResults) detail.reset(DetailedResults());
+    if (enableDetailedResults) detail = DetailedResults();
   }
 
   /// Return pointer to detail, 0 if no detail requested
-  DetailedResults* details() { return detail.get_ptr(); }
+  DetailedResults* details() {
+    if (detail.has_value()) {
+      return &(*detail);
+    } else {
+      return nullptr;
+    }
+  }
 
   /// Print results
   void print(const std::string str = "") const {
diff --git a/gtsam/nonlinear/ISAM2UpdateParams.h b/gtsam/nonlinear/ISAM2UpdateParams.h
index 0a3be1daf..fff047851 100644
--- a/gtsam/nonlinear/ISAM2UpdateParams.h
+++ b/gtsam/nonlinear/ISAM2UpdateParams.h
@@ -20,7 +20,7 @@
 #include <gtsam/dllexport.h>              // GTSAM_EXPORT
 #include <gtsam/inference/Key.h>          // Key, KeySet
 #include <gtsam/nonlinear/ISAM2Result.h>  //FactorIndices
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace gtsam {
 
@@ -37,16 +37,16 @@ struct ISAM2UpdateParams {
 
   /** An optional map of keys to group labels, such that a variable can be
    * constrained to a particular grouping in the BayesTree */
-  boost::optional<FastMap<Key, int>> constrainedKeys{boost::none};
+  std::optional<FastMap<Key, int>> constrainedKeys;
 
   /** An optional set of nonlinear keys that iSAM2 will hold at a constant
    * linearization point, regardless of the size of the linear delta */
-  boost::optional<FastList<Key>> noRelinKeys{boost::none};
+  std::optional<FastList<Key>> noRelinKeys;
 
   /** An optional set of nonlinear keys that iSAM2 will re-eliminate, regardless
    * of the size of the linear delta. This allows the provided keys to be
    * reordered. */
-  boost::optional<FastList<Key>> extraReelimKeys{boost::none};
+  std::optional<FastList<Key>> extraReelimKeys;
 
   /** Relinearize any variables whose delta magnitude is sufficiently large
    * (Params::relinearizeThreshold), regardless of the relinearization
@@ -63,7 +63,7 @@ struct ISAM2UpdateParams {
    *    depend on Keys `X(2)`, `X(3)`. Next call to ISAM2::update() must include
    *    its `newAffectedKeys` field with the map `13 -> {X(2), X(3)}`.
    */
-  boost::optional<FastMap<FactorIndex, KeySet>> newAffectedKeys{boost::none};
+  std::optional<FastMap<FactorIndex, KeySet>> newAffectedKeys;
 
   /** By default, iSAM2 uses a wildfire update scheme that stops updating when
    * the deltas become too small down in the tree. This flagg forces a full
diff --git a/gtsam/nonlinear/LevenbergMarquardtOptimizer.cpp b/gtsam/nonlinear/LevenbergMarquardtOptimizer.cpp
index 9b894db25..5cbed2a1f 100644
--- a/gtsam/nonlinear/LevenbergMarquardtOptimizer.cpp
+++ b/gtsam/nonlinear/LevenbergMarquardtOptimizer.cpp
@@ -29,7 +29,6 @@
 #include <gtsam/base/timing.h>
 
 #include <boost/format.hpp>
-#include <boost/optional.hpp>
 #include <boost/range/adaptor/map.hpp>
 
 #include <cmath>
diff --git a/gtsam/nonlinear/LinearContainerFactor.cpp b/gtsam/nonlinear/LinearContainerFactor.cpp
index 9ee0681d2..8b05bc2d9 100644
--- a/gtsam/nonlinear/LinearContainerFactor.cpp
+++ b/gtsam/nonlinear/LinearContainerFactor.cpp
@@ -21,13 +21,13 @@ void LinearContainerFactor::initializeLinearizationPoint(const Values& lineariza
       linearizationPoint_->insert(key, linearizationPoint.at(key));
     }
   } else {
-    linearizationPoint_ = boost::none;
+    linearizationPoint_ = {};
   }
 }
 
 /* ************************************************************************* */
 LinearContainerFactor::LinearContainerFactor(const GaussianFactor::shared_ptr& factor,
-    const boost::optional<Values>& linearizationPoint)
+    const std::optional<Values>& linearizationPoint)
 : NonlinearFactor(factor->keys()), factor_(factor), linearizationPoint_(linearizationPoint) {
 }
 
diff --git a/gtsam/nonlinear/LinearContainerFactor.h b/gtsam/nonlinear/LinearContainerFactor.h
index 16094b67a..3a0555af6 100644
--- a/gtsam/nonlinear/LinearContainerFactor.h
+++ b/gtsam/nonlinear/LinearContainerFactor.h
@@ -10,6 +10,9 @@
 #pragma once
 
 #include <gtsam/nonlinear/NonlinearFactorGraph.h>
+#include <gtsam/base/std_optional_serialization.h>
+
+#include <optional>
 
 namespace gtsam {
 
@@ -27,10 +30,10 @@ class GTSAM_EXPORT LinearContainerFactor : public NonlinearFactor {
 protected:
 
   GaussianFactor::shared_ptr factor_;
-  boost::optional<Values> linearizationPoint_;
+  std::optional<Values> linearizationPoint_;
 
   /** direct copy constructor */
-  LinearContainerFactor(const GaussianFactor::shared_ptr& factor, const boost::optional<Values>& linearizationPoint);
+  LinearContainerFactor(const GaussianFactor::shared_ptr& factor, const std::optional<Values>& linearizationPoint);
 
   // Some handy typedefs
   typedef NonlinearFactor Base;
@@ -80,7 +83,7 @@ public:
   size_t dim() const override;
 
   /** Extract the linearization point used in recalculating error */
-  const boost::optional<Values>& linearizationPoint() const { return linearizationPoint_; }
+  const std::optional<Values>& linearizationPoint() const { return linearizationPoint_; }
 
   /**
    * Linearize to a GaussianFactor, with method depending on the presence of a linearizationPoint
@@ -135,7 +138,7 @@ public:
   NonlinearFactor::shared_ptr rekey(const KeyVector& new_keys) const override;
 
   /// Casting syntactic sugar
-  inline bool hasLinearizationPoint() const { return linearizationPoint_.is_initialized(); }
+  inline bool hasLinearizationPoint() const { return linearizationPoint_.has_value(); }
 
   /**
    * Simple checks whether this is a Jacobian or Hessian factor
diff --git a/gtsam/nonlinear/NonlinearFactorGraph.cpp b/gtsam/nonlinear/NonlinearFactorGraph.cpp
index dfa54f26f..3b7efd790 100644
--- a/gtsam/nonlinear/NonlinearFactorGraph.cpp
+++ b/gtsam/nonlinear/NonlinearFactorGraph.cpp
@@ -129,7 +129,7 @@ void NonlinearFactorGraph::dot(std::ostream& os, const Values& values,
     // Create factors and variable connections
     size_t i = 0;
     for (const KeyVector& factorKeys : structure) {
-      writer.processFactor(i++, factorKeys, keyFormatter, boost::none, &os);
+      writer.processFactor(i++, factorKeys, keyFormatter, {}, &os);
     }
   } else {
     // Create factors and variable connections
diff --git a/gtsam/nonlinear/NonlinearOptimizerParams.h b/gtsam/nonlinear/NonlinearOptimizerParams.h
index 218230421..7184b3dfc 100644
--- a/gtsam/nonlinear/NonlinearOptimizerParams.h
+++ b/gtsam/nonlinear/NonlinearOptimizerParams.h
@@ -23,8 +23,9 @@
 
 #include <gtsam/linear/GaussianFactorGraph.h>
 #include <gtsam/linear/SubgraphSolver.h>
-#include <boost/optional.hpp>
+
 #include <string>
+#include <optional>
 
 namespace gtsam {
 
@@ -104,7 +105,7 @@ public:
   };
 
   LinearSolverType linearSolverType = MULTIFRONTAL_CHOLESKY; ///< The type of linear solver to use in the nonlinear optimizer
-  boost::optional<Ordering> ordering; ///< The optional variable elimination ordering, or empty to use COLAMD (default: empty)
+  std::optional<Ordering> ordering; ///< The optional variable elimination ordering, or empty to use COLAMD (default: empty)
   IterativeOptimizationParameters::shared_ptr iterativeParams; ///< The container for iterativeOptimization parameters. used in CG Solvers.
 
   NonlinearOptimizerParams() = default;
diff --git a/gtsam/nonlinear/internal/ExecutionTrace.h b/gtsam/nonlinear/internal/ExecutionTrace.h
index 2943b5e68..17557ba3a 100644
--- a/gtsam/nonlinear/internal/ExecutionTrace.h
+++ b/gtsam/nonlinear/internal/ExecutionTrace.h
@@ -26,6 +26,7 @@
 
 #include <Eigen/Core>
 #include <iostream>
+#include <optional>
 
 namespace gtsam {
 namespace internal {
@@ -132,12 +133,12 @@ class ExecutionTrace {
 
   /// Return record pointer, quite unsafe, used only for testing
   template<class Record>
-  boost::optional<Record*> record() {
+  std::optional<Record*> record() {
     if (kind != Function)
-      return boost::none;
+      return {};
     else {
       Record* p = dynamic_cast<Record*>(content.ptr);
-      return p ? boost::optional<Record*>(p) : boost::none;
+      return p ? std::optional<Record*>(p) : std::nullopt;
     }
   }
 
diff --git a/gtsam/nonlinear/internal/ExpressionNode.h b/gtsam/nonlinear/internal/ExpressionNode.h
index f6afb287e..4c34a1777 100644
--- a/gtsam/nonlinear/internal/ExpressionNode.h
+++ b/gtsam/nonlinear/internal/ExpressionNode.h
@@ -255,7 +255,7 @@ public:
 
   /// Return value
   T value(const Values& values) const override {
-    return function_(expression1_->value(values), boost::none);
+    return function_(expression1_->value(values), {});
   }
 
   /// Return keys that play in this expression
@@ -365,9 +365,9 @@ public:
 
   /// Return value
   T value(const Values& values) const override {
-    using boost::none;
+    using std::nullopt;
     return function_(expression1_->value(values), expression2_->value(values),
-        none, none);
+        {}, {});
   }
 
   /// Return keys that play in this expression
@@ -473,9 +473,9 @@ public:
 
   /// Return value
   T value(const Values& values) const override {
-    using boost::none;
+    using std::nullopt;
     return function_(expression1_->value(values), expression2_->value(values),
-        expression3_->value(values), none, none, none);
+        expression3_->value(values), {}, {}, {});
   }
 
   /// Return keys that play in this expression
diff --git a/gtsam/nonlinear/nonlinear.i b/gtsam/nonlinear/nonlinear.i
index 80e87a5fa..3e3373f61 100644
--- a/gtsam/nonlinear/nonlinear.i
+++ b/gtsam/nonlinear/nonlinear.i
@@ -392,7 +392,7 @@ virtual class LinearContainerFactor : gtsam::NonlinearFactor {
   LinearContainerFactor(gtsam::GaussianFactor* factor);
 
   gtsam::GaussianFactor* factor() const;
-  //  const boost::optional<Values>& linearizationPoint() const;
+  //  const std::optional<Values>& linearizationPoint() const;
 
   bool isJacobian() const;
   gtsam::JacobianFactor* toJacobian() const;
diff --git a/gtsam/nonlinear/tests/testExpression.cpp b/gtsam/nonlinear/tests/testExpression.cpp
index a93f8a0e1..06ad16dfd 100644
--- a/gtsam/nonlinear/tests/testExpression.cpp
+++ b/gtsam/nonlinear/tests/testExpression.cpp
@@ -119,7 +119,7 @@ class Class : public Point3 {
   using Point3::Point3;
   const Vector3& vector() const { return *this; }
   inline static Class Identity() { return Class(0,0,0); }
-  double norm(OptionalJacobian<1,3> H = boost::none) const {
+  double norm(OptionalJacobian<1,3> H = {}) const {
     return norm3(*this, H);
   }
   bool equals(const Class &q, double tol) const {
diff --git a/gtsam/nonlinear/tests/testFactorTesting.cpp b/gtsam/nonlinear/tests/testFactorTesting.cpp
index 53111e1af..48f61a971 100644
--- a/gtsam/nonlinear/tests/testFactorTesting.cpp
+++ b/gtsam/nonlinear/tests/testFactorTesting.cpp
@@ -28,8 +28,8 @@ using namespace gtsam;
 /* ************************************************************************* */
 Vector3 bodyVelocity(const Pose3& w_t_b,
                      const Vector3& vec_w,
-                     OptionalJacobian<3, 6> Hpose = boost::none,
-                     OptionalJacobian<3, 3> Hvel = boost::none) {
+                     OptionalJacobian<3, 6> Hpose = {},
+                     OptionalJacobian<3, 3> Hvel = {}) {
   Matrix36 Hrot__pose;
   Rot3 w_R_b = w_t_b.rotation(Hrot__pose);
   Matrix33 Hvel__rot;
@@ -51,7 +51,7 @@ class ScaledVelocityFunctor {
   // and velocity scale factor. Also computes the corresponding jacobian
   // (w.r.t. the velocity scale).
   Vector3 operator()(double vscale,
-                     OptionalJacobian<3, 1> H = boost::none) const {
+                     OptionalJacobian<3, 1> H = {}) const {
     // The velocity scale factor value we are optimizing for is centered around
     // 0, so we need to add 1 to it before scaling the velocity.
     const Vector3 scaled_velocity = (vscale + 1.0) * measured_velocity_;
diff --git a/gtsam/nonlinear/tests/testFunctorizedFactor.cpp b/gtsam/nonlinear/tests/testFunctorizedFactor.cpp
index dbc22c079..f4ed70885 100644
--- a/gtsam/nonlinear/tests/testFunctorizedFactor.cpp
+++ b/gtsam/nonlinear/tests/testFunctorizedFactor.cpp
@@ -47,7 +47,7 @@ class MultiplyFunctor {
   MultiplyFunctor(double m) : m_(m) {}
 
   Matrix operator()(const Matrix &X,
-                    OptionalJacobian<-1, -1> H = boost::none) const {
+                    OptionalJacobian<-1, -1> H = {}) const {
     if (H) *H = m_ * Matrix::Identity(X.rows() * X.cols(), X.rows() * X.cols());
     return m_ * X;
   }
@@ -57,8 +57,8 @@ class MultiplyFunctor {
 class ProjectionFunctor {
  public:
   Vector operator()(const Matrix &A, const Vector &x,
-                    OptionalJacobian<-1, -1> H1 = boost::none,
-                    OptionalJacobian<-1, -1> H2 = boost::none) const {
+                    OptionalJacobian<-1, -1> H1 = {},
+                    OptionalJacobian<-1, -1> H2 = {}) const {
     if (H1) {
       H1->resize(x.size(), A.size());
       *H1 << I_3x3, I_3x3, I_3x3;
@@ -178,7 +178,7 @@ TEST(FunctorizedFactor, Lambda) {
   Matrix measurement = multiplier * Matrix::Identity(3, 3);
 
   auto lambda = [multiplier](const Matrix &X,
-                             OptionalJacobian<-1, -1> H = boost::none) {
+                             OptionalJacobian<-1, -1> H = {}) {
     if (H)
       *H = multiplier *
            Matrix::Identity(X.rows() * X.cols(), X.rows() * X.cols());
@@ -251,8 +251,8 @@ TEST(FunctorizedFactor, Lambda2) {
   Matrix measurement = A * x;
 
   auto lambda = [](const Matrix &A, const Vector &x,
-                   OptionalJacobian<-1, -1> H1 = boost::none,
-                   OptionalJacobian<-1, -1> H2 = boost::none) {
+                   OptionalJacobian<-1, -1> H1 = {},
+                   OptionalJacobian<-1, -1> H2 = {}) {
     if (H1) {
       H1->resize(x.size(), A.size());
       *H1 << I_3x3, I_3x3, I_3x3;
diff --git a/gtsam/nonlinear/tests/testValues.cpp b/gtsam/nonlinear/tests/testValues.cpp
index 2db5d83ff..9ec1c53d1 100644
--- a/gtsam/nonlinear/tests/testValues.cpp
+++ b/gtsam/nonlinear/tests/testValues.cpp
@@ -60,13 +60,13 @@ public:
   bool equals(const TestValue& other, double tol = 1e-9) const { return true; }
   size_t dim() const { return 0; }
   TestValue retract(const Vector&,
-                    OptionalJacobian<dimension,dimension> H1=boost::none,
-                    OptionalJacobian<dimension,dimension> H2=boost::none) const {
+                    OptionalJacobian<dimension,dimension> H1={},
+                    OptionalJacobian<dimension,dimension> H2={}) const {
     return TestValue();
   }
   Vector localCoordinates(const TestValue&,
-                          OptionalJacobian<dimension,dimension> H1=boost::none,
-                          OptionalJacobian<dimension,dimension> H2=boost::none) const {
+                          OptionalJacobian<dimension,dimension> H1={},
+                          OptionalJacobian<dimension,dimension> H2={}) const {
     return Vector();
   }
 };
diff --git a/gtsam/sfm/DsfTrackGenerator.h b/gtsam/sfm/DsfTrackGenerator.h
index 14ec2302d..518a5d10b 100644
--- a/gtsam/sfm/DsfTrackGenerator.h
+++ b/gtsam/sfm/DsfTrackGenerator.h
@@ -43,13 +43,13 @@ struct Keypoints {
 
   // Optional scale of the detections, of shape N.
   // Note: gtsam::Vector is typedef'd for Eigen::VectorXd.
-  boost::optional<gtsam::Vector> scales;
+  std::optional<gtsam::Vector> scales;
 
   /// Optional confidences/responses for each detection, of shape N.
-  boost::optional<gtsam::Vector> responses;
+  std::optional<gtsam::Vector> responses;
 
   Keypoints(const Eigen::MatrixX2d& coordinates)
-      : coordinates(coordinates){};  // boost::none
+      : coordinates(coordinates){};  // std::nullopt
 };
 
 using KeypointsVector = std::vector<Keypoints>;
diff --git a/gtsam/sfm/SfmData.cpp b/gtsam/sfm/SfmData.cpp
index 246c65c4a..6c6b471e6 100644
--- a/gtsam/sfm/SfmData.cpp
+++ b/gtsam/sfm/SfmData.cpp
@@ -405,8 +405,8 @@ NonlinearFactorGraph SfmData::generalSfmFactors(
 
 /* ************************************************************************** */
 NonlinearFactorGraph SfmData::sfmFactorGraph(
-    const SharedNoiseModel &model, boost::optional<size_t> fixedCamera,
-    boost::optional<size_t> fixedPoint) const {
+    const SharedNoiseModel &model, std::optional<size_t> fixedCamera,
+    std::optional<size_t> fixedPoint) const {
   NonlinearFactorGraph graph = generalSfmFactors(model);
   using noiseModel::Constrained;
   if (fixedCamera) {
diff --git a/gtsam/sfm/SfmData.h b/gtsam/sfm/SfmData.h
index cc9bd86f6..dbf0bd1e7 100644
--- a/gtsam/sfm/SfmData.h
+++ b/gtsam/sfm/SfmData.h
@@ -102,14 +102,14 @@ struct GTSAM_EXPORT SfmData {
    * Note: pose keys are simply integer indices, points use Symbol('p', j).
    *
    * @param model a noise model for projection errors
-   * @param fixedCamera which camera to fix, if any (use boost::none if none)
-   * @param fixedPoint which point to fix, if any (use boost::none if none)
+   * @param fixedCamera which camera to fix, if any (use std::nullopt if none)
+   * @param fixedPoint which point to fix, if any (use std::nullopt if none)
    * @return NonlinearFactorGraph
    */
   NonlinearFactorGraph sfmFactorGraph(
       const SharedNoiseModel& model = noiseModel::Isotropic::Sigma(2, 1.0),
-      boost::optional<size_t> fixedCamera = 0,
-      boost::optional<size_t> fixedPoint = 0) const;
+      std::optional<size_t> fixedCamera = 0,
+      std::optional<size_t> fixedPoint = 0) const;
 
   /// @}
   /// @name Testable
diff --git a/gtsam/sfm/ShonanAveraging.cpp b/gtsam/sfm/ShonanAveraging.cpp
index ea4171238..9e5645a57 100644
--- a/gtsam/sfm/ShonanAveraging.cpp
+++ b/gtsam/sfm/ShonanAveraging.cpp
@@ -554,7 +554,7 @@ static bool PowerMinimumEigenValue(
   }
 
   const Sparse C = pmEigenValue * Matrix::Identity(A.rows(), A.cols()).sparseView() - A;
-  const boost::optional<Vector> initial = perturb(S.row(0));
+  const std::optional<Vector> initial = perturb(S.row(0));
   AcceleratedPowerMethod<Sparse> apmShiftedOperator(C, initial);
 
   const bool minConverged = apmShiftedOperator.compute(
diff --git a/gtsam/sfm/ShonanGaugeFactor.h b/gtsam/sfm/ShonanGaugeFactor.h
index d814aafa1..3152ad9d0 100644
--- a/gtsam/sfm/ShonanGaugeFactor.h
+++ b/gtsam/sfm/ShonanGaugeFactor.h
@@ -56,7 +56,7 @@ public:
    * the Jacobian will be multiplied with 1/sigma = sqrt(gamma).
    */
   ShonanGaugeFactor(Key key, size_t p, size_t d = 3,
-                    boost::optional<double> gamma = boost::none)
+                    std::optional<double> gamma = {})
       : NonlinearFactor(KeyVector{key}) {
     if (p < d) {
       throw std::invalid_argument("ShonanGaugeFactor must have p>=d.");
@@ -103,4 +103,4 @@ public:
 };
 // \ShonanGaugeFactor
 
-} // namespace gtsam
\ No newline at end of file
+} // namespace gtsam
diff --git a/gtsam/slam/GeneralSFMFactor.h b/gtsam/slam/GeneralSFMFactor.h
index 3f405f985..78fdb189a 100644
--- a/gtsam/slam/GeneralSFMFactor.h
+++ b/gtsam/slam/GeneralSFMFactor.h
@@ -37,7 +37,6 @@
 #include <gtsam/base/timing.h>
 
 #include <boost/none.hpp>
-#include <boost/optional/optional.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <iostream>
diff --git a/gtsam/slam/KarcherMeanFactor-inl.h b/gtsam/slam/KarcherMeanFactor-inl.h
index 00f741705..e714f653b 100644
--- a/gtsam/slam/KarcherMeanFactor-inl.h
+++ b/gtsam/slam/KarcherMeanFactor-inl.h
@@ -20,6 +20,7 @@
 #include <gtsam/nonlinear/GaussNewtonOptimizer.h>
 #include <gtsam/nonlinear/NonlinearFactorGraph.h>
 #include <gtsam/slam/KarcherMeanFactor.h>
+#include <optional>
 
 using namespace std;
 
@@ -58,7 +59,7 @@ T FindKarcherMean(std::initializer_list<T>&& rotations) {
 template <class T>
 template <typename CONTAINER>
 KarcherMeanFactor<T>::KarcherMeanFactor(const CONTAINER &keys, int d,
-                                        boost::optional<double> beta)
+                                        std::optional<double> beta)
     : NonlinearFactor(keys), d_(static_cast<size_t>(d)) {
   if (d <= 0) {
     throw std::invalid_argument(
@@ -75,4 +76,4 @@ KarcherMeanFactor<T>::KarcherMeanFactor(const CONTAINER &keys, int d,
   whitenedJacobian_ =
       boost::make_shared<JacobianFactor>(terms, Vector::Zero(d));
 }
-}  // namespace gtsam
\ No newline at end of file
+}  // namespace gtsam
diff --git a/gtsam/slam/KarcherMeanFactor.h b/gtsam/slam/KarcherMeanFactor.h
index 964cd598f..2b230c2f2 100644
--- a/gtsam/slam/KarcherMeanFactor.h
+++ b/gtsam/slam/KarcherMeanFactor.h
@@ -22,6 +22,7 @@
 
 #include <map>
 #include <vector>
+#include <optional>
 
 namespace gtsam {
 /**
@@ -60,7 +61,7 @@ public:
    */
   template <typename CONTAINER>
   KarcherMeanFactor(const CONTAINER &keys, int d = D,
-                    boost::optional<double> beta = boost::none);
+                    std::optional<double> beta = {});
 
   /// Destructor
   ~KarcherMeanFactor() override {}
diff --git a/gtsam/slam/ProjectionFactor.h b/gtsam/slam/ProjectionFactor.h
index b263b4de6..e8824d22b 100644
--- a/gtsam/slam/ProjectionFactor.h
+++ b/gtsam/slam/ProjectionFactor.h
@@ -25,7 +25,7 @@
 #include <gtsam/geometry/Pose3.h>
 #include <gtsam/geometry/Point3.h>
 #include <gtsam/geometry/Cal3_S2.h>
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace gtsam {
 
@@ -43,7 +43,7 @@ namespace gtsam {
     // Keep a copy of measurement and calibration for I/O
     Point2 measured_;                    ///< 2D measurement
     boost::shared_ptr<CALIBRATION> K_;  ///< shared pointer to calibration object
-    boost::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
+    std::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
 
     // verbosity handling for Cheirality Exceptions
     bool throwCheirality_; ///< If true, rethrows Cheirality exceptions (default: false)
@@ -80,7 +80,7 @@ namespace gtsam {
      */
     GenericProjectionFactor(const Point2& measured, const SharedNoiseModel& model,
         Key poseKey, Key pointKey, const boost::shared_ptr<CALIBRATION>& K,
-        boost::optional<POSE> body_P_sensor = boost::none) :
+        std::optional<POSE> body_P_sensor = {}) :
           Base(model, poseKey, pointKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
           throwCheirality_(false), verboseCheirality_(false) {}
 
@@ -99,7 +99,7 @@ namespace gtsam {
     GenericProjectionFactor(const Point2& measured, const SharedNoiseModel& model,
         Key poseKey, Key pointKey, const boost::shared_ptr<CALIBRATION>& K,
         bool throwCheirality, bool verboseCheirality,
-        boost::optional<POSE> body_P_sensor = boost::none) :
+        std::optional<POSE> body_P_sensor = {}) :
           Base(model, poseKey, pointKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
           throwCheirality_(throwCheirality), verboseCheirality_(verboseCheirality) {}
 
@@ -142,16 +142,16 @@ namespace gtsam {
           if(H1) {
             gtsam::Matrix H0;
             PinholeCamera<CALIBRATION> camera(pose.compose(*body_P_sensor_, H0), *K_);
-            Point2 reprojectionError(camera.project(point, H1, H2, boost::none) - measured_);
+            Point2 reprojectionError(camera.project(point, H1, H2, {}) - measured_);
             *H1 = *H1 * H0;
             return reprojectionError;
           } else {
             PinholeCamera<CALIBRATION> camera(pose.compose(*body_P_sensor_), *K_);
-            return camera.project(point, H1, H2, boost::none) - measured_;
+            return camera.project(point, H1, H2, {}) - measured_;
           }
         } else {
           PinholeCamera<CALIBRATION> camera(pose, *K_);
-          return camera.project(point, H1, H2, boost::none) - measured_;
+          return camera.project(point, H1, H2, {}) - measured_;
         }
       } catch( CheiralityException& e) {
         if (H1) *H1 = Matrix::Zero(2,6);
@@ -176,7 +176,7 @@ namespace gtsam {
     }
 
     /** return the (optional) sensor pose with respect to the vehicle frame */
-    const boost::optional<POSE>& body_P_sensor() const {
+    const std::optional<POSE>& body_P_sensor() const {
       return body_P_sensor_;
     }
 
diff --git a/gtsam/slam/SmartFactorBase.h b/gtsam/slam/SmartFactorBase.h
index b53235ab3..1eba3c953 100644
--- a/gtsam/slam/SmartFactorBase.h
+++ b/gtsam/slam/SmartFactorBase.h
@@ -29,7 +29,7 @@
 #include <gtsam/linear/RegularHessianFactor.h>
 #include <gtsam/geometry/CameraSet.h>
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <boost/serialization/optional.hpp>
 #include <boost/make_shared.hpp>
 #include <vector>
@@ -78,7 +78,7 @@ protected:
    */
   ZVector measured_;
 
-  boost::optional<Pose3>
+  std::optional<Pose3>
       body_P_sensor_;  ///< Pose of the camera in the body frame
 
   // Cache for Fblocks, to avoid a malloc ever time we re-linearize
@@ -98,7 +98,7 @@ protected:
 
   /// Construct with given noise model and optional arguments.
   SmartFactorBase(const SharedNoiseModel& sharedNoiseModel,
-                  boost::optional<Pose3> body_P_sensor = boost::none,
+                  std::optional<Pose3> body_P_sensor = {},
                   size_t expectedNumberCameras = 10)
       : body_P_sensor_(body_P_sensor), Fs(expectedNumberCameras) {
 
diff --git a/gtsam/slam/SmartProjectionFactor.h b/gtsam/slam/SmartProjectionFactor.h
index d09f42509..a38a8bd88 100644
--- a/gtsam/slam/SmartProjectionFactor.h
+++ b/gtsam/slam/SmartProjectionFactor.h
@@ -26,7 +26,7 @@
 #include <gtsam/inference/Symbol.h>
 #include <gtsam/slam/dataset.h>
 
-#include <boost/optional.hpp>
+#include <optional>
 #include <boost/make_shared.hpp>
 #include <vector>
 
@@ -410,7 +410,7 @@ protected:
    * to transform it to \f$ (h(x)-z)^2/\sigma^2 \f$, and then multiply by 0.5.
    */
   double totalReprojectionError(const Cameras& cameras,
-      boost::optional<Point3> externalPoint = boost::none) const {
+      std::optional<Point3> externalPoint = {}) const {
 
     if (externalPoint)
       result_ = TriangulationResult(*externalPoint);
diff --git a/gtsam/slam/SmartProjectionPoseFactor.h b/gtsam/slam/SmartProjectionPoseFactor.h
index e432cbfb1..ce84babed 100644
--- a/gtsam/slam/SmartProjectionPoseFactor.h
+++ b/gtsam/slam/SmartProjectionPoseFactor.h
@@ -86,7 +86,7 @@ public:
   SmartProjectionPoseFactor(
       const SharedNoiseModel& sharedNoiseModel,
       const boost::shared_ptr<CALIBRATION> K,
-      const boost::optional<Pose3> body_P_sensor,
+      const std::optional<Pose3> body_P_sensor,
       const SmartProjectionParams& params = SmartProjectionParams())
       : SmartProjectionPoseFactor(sharedNoiseModel, K, params) {
     this->body_P_sensor_ = body_P_sensor;
diff --git a/gtsam/slam/StereoFactor.h b/gtsam/slam/StereoFactor.h
index c0e3fd1b3..d52860776 100644
--- a/gtsam/slam/StereoFactor.h
+++ b/gtsam/slam/StereoFactor.h
@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <optional>
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam/geometry/StereoCamera.h>
 
@@ -34,7 +35,7 @@ private:
   // Keep a copy of measurement and calibration for I/O
   StereoPoint2 measured_;                      ///< the measurement
   Cal3_S2Stereo::shared_ptr K_;                ///< shared pointer to calibration
-  boost::optional<POSE> body_P_sensor_;        ///< The pose of the sensor in the body frame
+  std::optional<POSE> body_P_sensor_;        ///< The pose of the sensor in the body frame
 
   // verbosity handling for Cheirality Exceptions
   bool throwCheirality_;                       ///< If true, rethrows Cheirality exceptions (default: false)
@@ -68,7 +69,7 @@ public:
    */
   GenericStereoFactor(const StereoPoint2& measured, const SharedNoiseModel& model,
       Key poseKey, Key landmarkKey, const Cal3_S2Stereo::shared_ptr& K,
-      boost::optional<POSE> body_P_sensor = boost::none) :
+      std::optional<POSE> body_P_sensor = {}) :
     Base(model, poseKey, landmarkKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
     throwCheirality_(false), verboseCheirality_(false) {}
 
@@ -86,7 +87,7 @@ public:
   GenericStereoFactor(const StereoPoint2& measured, const SharedNoiseModel& model,
       Key poseKey, Key landmarkKey, const Cal3_S2Stereo::shared_ptr& K,
       bool throwCheirality, bool verboseCheirality,
-      boost::optional<POSE> body_P_sensor = boost::none) :
+      std::optional<POSE> body_P_sensor = {}) :
     Base(model, poseKey, landmarkKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
     throwCheirality_(throwCheirality), verboseCheirality_(verboseCheirality) {}
 
diff --git a/gtsam/slam/TriangulationFactor.h b/gtsam/slam/TriangulationFactor.h
index 6fac062b9..bd8354435 100644
--- a/gtsam/slam/TriangulationFactor.h
+++ b/gtsam/slam/TriangulationFactor.h
@@ -163,7 +163,7 @@ public:
 
     // Would be even better if we could pass blocks to project
     const Point3& point = x.at<Point3>(key());
-    b = traits<Measurement>::Local(camera_.project2(point, boost::none, A), measured_);
+    b = traits<Measurement>::Local(camera_.project2(point, {}, A), measured_);
     if (noiseModel_)
       this->noiseModel_->WhitenSystem(A, b);
 
diff --git a/gtsam/slam/dataset.cpp b/gtsam/slam/dataset.cpp
index 5eaa00720..318e4dd07 100644
--- a/gtsam/slam/dataset.cpp
+++ b/gtsam/slam/dataset.cpp
@@ -43,7 +43,7 @@
 
 #include <boost/filesystem/operations.hpp>
 #include <boost/filesystem/path.hpp>
-#include <boost/optional.hpp>
+#include <optional>
 
 #include <cmath>
 #include <fstream>
@@ -113,7 +113,7 @@ string createRewrittenFileName(const string &name) {
 // Type for parser functions used in parseLines below.
 template <typename T>
 using Parser =
-    std::function<boost::optional<T>(istream &is, const string &tag)>;
+    std::function<std::optional<T>(istream &is, const string &tag)>;
 
 // Parse a file by calling the parse(is, tag) function for every line.
 // The result of calling the function is ignored, so typically parse function
@@ -141,7 +141,7 @@ map<size_t, T> parseToMap(const string &filename, Parser<pair<size_t, T>> parse,
       if (!maxIndex || t->first <= maxIndex)
         result.emplace(*t);
     }
-    return boost::none;
+    return std::nullopt;
   };
   parseLines(filename, emplace);
   return result;
@@ -155,14 +155,14 @@ static vector<T> parseToVector(const string &filename, Parser<T> parse) {
   Parser<T> add = [&result, parse](istream &is, const string &tag) {
     if (auto t = parse(is, tag))
       result.push_back(*t);
-    return boost::none;
+    return std::nullopt;
   };
   parseLines(filename, add);
   return result;
 }
 
 /* ************************************************************************* */
-boost::optional<IndexedPose> parseVertexPose(istream &is, const string &tag) {
+std::optional<IndexedPose> parseVertexPose(istream &is, const string &tag) {
   if ((tag == "VERTEX2") || (tag == "VERTEX_SE2") || (tag == "VERTEX")) {
     size_t id;
     double x, y, yaw;
@@ -171,7 +171,7 @@ boost::optional<IndexedPose> parseVertexPose(istream &is, const string &tag) {
     }
     return IndexedPose(id, Pose2(x, y, yaw));
   } else {
-    return boost::none;
+    return std::nullopt;
   }
 }
 
@@ -182,7 +182,7 @@ GTSAM_EXPORT std::map<size_t, Pose2> parseVariables<Pose2>(
 }
 
 /* ************************************************************************* */
-boost::optional<IndexedLandmark> parseVertexLandmark(istream &is,
+std::optional<IndexedLandmark> parseVertexLandmark(istream &is,
                                                      const string &tag) {
   if (tag == "VERTEX_XY") {
     size_t id;
@@ -193,7 +193,7 @@ boost::optional<IndexedLandmark> parseVertexLandmark(istream &is,
     }
     return IndexedLandmark(id, Point2(x, y));
   } else {
-    return boost::none;
+    return std::nullopt;
   }
 }
 
@@ -288,7 +288,7 @@ static SharedNoiseModel createNoiseModel(
 }
 
 /* ************************************************************************* */
-boost::optional<IndexedEdge> parseEdge(istream &is, const string &tag) {
+std::optional<IndexedEdge> parseEdge(istream &is, const string &tag) {
   if ((tag == "EDGE2") || (tag == "EDGE") || (tag == "EDGE_SE2") ||
       (tag == "ODOMETRY")) {
 
@@ -299,7 +299,7 @@ boost::optional<IndexedEdge> parseEdge(istream &is, const string &tag) {
     }
     return IndexedEdge({id1, id2}, Pose2(x, y, yaw));
   } else {
-    return boost::none;
+    return std::nullopt;
   }
 }
 
@@ -315,13 +315,13 @@ template <typename T> struct ParseFactor : ParseMeasurement<T> {
       : ParseMeasurement<T>(parent) {}
 
   // We parse a measurement then convert
-  typename boost::optional<typename BetweenFactor<T>::shared_ptr>
+  typename std::optional<typename BetweenFactor<T>::shared_ptr>
   operator()(istream &is, const string &tag) {
     if (auto m = ParseMeasurement<T>::operator()(is, tag))
       return boost::make_shared<BetweenFactor<T>>(
           m->key1(), m->key2(), m->measured(), m->noiseModel());
     else
-      return boost::none;
+      return std::nullopt;
   }
 };
 
@@ -341,11 +341,11 @@ template <> struct ParseMeasurement<Pose2> {
   SharedNoiseModel model;
 
   // The actual parser
-  boost::optional<BinaryMeasurement<Pose2>> operator()(istream &is,
+  std::optional<BinaryMeasurement<Pose2>> operator()(istream &is,
                                                        const string &tag) {
     auto edge = parseEdge(is, tag);
     if (!edge)
-      return boost::none;
+      return std::nullopt;
 
     // parse noise model
     Vector6 v;
@@ -355,7 +355,7 @@ template <> struct ParseMeasurement<Pose2> {
     size_t id1, id2;
     tie(id1, id2) = edge->first;
     if (maxIndex && (id1 > maxIndex || id2 > maxIndex))
-      return boost::none;
+      return std::nullopt;
 
     // Get pose and optionally add noise
     Pose2 &pose = edge->second;
@@ -446,10 +446,10 @@ template <> struct ParseMeasurement<BearingRange2D> {
   size_t maxIndex;
 
   // The actual parser
-  boost::optional<BinaryMeasurement<BearingRange2D>>
+  std::optional<BinaryMeasurement<BearingRange2D>>
   operator()(istream &is, const string &tag) {
     if (tag != "BR" && tag != "LANDMARK")
-      return boost::none;
+      return std::nullopt;
 
     size_t id1, id2;
     is >> id1 >> id2;
@@ -485,7 +485,7 @@ template <> struct ParseMeasurement<BearingRange2D> {
 
     // optional filter
     if (maxIndex && id1 > maxIndex)
-      return boost::none;
+      return std::nullopt;
 
     // Create noise model
     auto measurementNoise = noiseModel::Diagonal::Sigmas(
@@ -759,7 +759,7 @@ istream &operator>>(istream &is, Rot3 &R) {
 }
 
 /* ************************************************************************* */
-boost::optional<pair<size_t, Pose3>> parseVertexPose3(istream &is,
+std::optional<pair<size_t, Pose3>> parseVertexPose3(istream &is,
                                                       const string &tag) {
   if (tag == "VERTEX3") {
     size_t id;
@@ -774,7 +774,7 @@ boost::optional<pair<size_t, Pose3>> parseVertexPose3(istream &is,
     is >> id >> x >> y >> z >> q;
     return make_pair(id, Pose3(q, {x, y, z}));
   } else
-    return boost::none;
+    return std::nullopt;
 }
 
 template <>
@@ -784,7 +784,7 @@ GTSAM_EXPORT std::map<size_t, Pose3> parseVariables<Pose3>(
 }
 
 /* ************************************************************************* */
-boost::optional<pair<size_t, Point3>> parseVertexPoint3(istream &is,
+std::optional<pair<size_t, Point3>> parseVertexPoint3(istream &is,
                                                         const string &tag) {
   if (tag == "VERTEX_TRACKXYZ") {
     size_t id;
@@ -792,7 +792,7 @@ boost::optional<pair<size_t, Point3>> parseVertexPoint3(istream &is,
     is >> id >> x >> y >> z;
     return make_pair(id, Point3(x, y, z));
   } else
-    return boost::none;
+    return std::nullopt;
 }
 
 template <>
@@ -820,16 +820,16 @@ template <> struct ParseMeasurement<Pose3> {
   size_t maxIndex;
 
   // The actual parser
-  boost::optional<BinaryMeasurement<Pose3>> operator()(istream &is,
+  std::optional<BinaryMeasurement<Pose3>> operator()(istream &is,
                                                        const string &tag) {
     if (tag != "EDGE3" && tag != "EDGE_SE3:QUAT")
-      return boost::none;
+      return std::nullopt;
 
     // parse ids and optionally filter
     size_t id1, id2;
     is >> id1 >> id2;
     if (maxIndex && (id1 > maxIndex || id2 > maxIndex))
-      return boost::none;
+      return std::nullopt;
 
     Matrix6 m;
     if (tag == "EDGE3") {
@@ -864,7 +864,7 @@ template <> struct ParseMeasurement<Pose3> {
       return BinaryMeasurement<Pose3>(
           id1, id2, T12, noiseModel::Gaussian::Information(mgtsam));
     } else
-      return boost::none;
+      return std::nullopt;
   }
 };
 
diff --git a/gtsam/slam/dataset.h b/gtsam/slam/dataset.h
index fcfe4b96c..d5bad59b4 100644
--- a/gtsam/slam/dataset.h
+++ b/gtsam/slam/dataset.h
@@ -40,6 +40,7 @@
 #include <vector>
 #include <iosfwd>
 #include <map>
+#include <optional>
 
 namespace gtsam {
 
@@ -118,7 +119,7 @@ typedef std::pair<std::pair<size_t, size_t>, Pose2> IndexedEdge;
  * @param is input stream
  * @param tag string parsed from input stream, will only parse if vertex type
  */
-GTSAM_EXPORT boost::optional<IndexedPose> parseVertexPose(std::istream& is,
+GTSAM_EXPORT std::optional<IndexedPose> parseVertexPose(std::istream& is,
     const std::string& tag);
 
 /**
@@ -126,7 +127,7 @@ GTSAM_EXPORT boost::optional<IndexedPose> parseVertexPose(std::istream& is,
  * @param is input stream
  * @param tag string parsed from input stream, will only parse if vertex type
  */
-GTSAM_EXPORT boost::optional<IndexedLandmark> parseVertexLandmark(std::istream& is,
+GTSAM_EXPORT std::optional<IndexedLandmark> parseVertexLandmark(std::istream& is,
     const std::string& tag);
 
 /**
@@ -134,7 +135,7 @@ GTSAM_EXPORT boost::optional<IndexedLandmark> parseVertexLandmark(std::istream&
  * @param is input stream
  * @param tag string parsed from input stream, will only parse if edge type
  */
-GTSAM_EXPORT boost::optional<IndexedEdge> parseEdge(std::istream& is,
+GTSAM_EXPORT std::optional<IndexedEdge> parseEdge(std::istream& is,
     const std::string& tag);
 
 /// Return type for load functions, which return a graph and initial values. For
diff --git a/gtsam/slam/tests/PinholeFactor.h b/gtsam/slam/tests/PinholeFactor.h
index 35500ca35..7266a4aea 100644
--- a/gtsam/slam/tests/PinholeFactor.h
+++ b/gtsam/slam/tests/PinholeFactor.h
@@ -35,7 +35,7 @@ class PinholeFactor : public SmartFactorBase<PinholeCamera<Cal3Bundler> > {
   typedef SmartFactorBase<PinholeCamera<Cal3Bundler> > Base;
   PinholeFactor() {}
   PinholeFactor(const SharedNoiseModel& sharedNoiseModel,
-                boost::optional<Pose3> body_P_sensor = boost::none,
+                std::optional<Pose3> body_P_sensor = {},
                 size_t expectedNumberCameras = 10)
       : Base(sharedNoiseModel, body_P_sensor, expectedNumberCameras) {}
   double error(const Values& values) const override { return 0.0; }
diff --git a/gtsam/slam/tests/testSerializationInSlam.cpp b/gtsam/slam/tests/testSerializationInSlam.cpp
index 08fb80c0a..f729f8ed6 100644
--- a/gtsam/slam/tests/testSerializationInSlam.cpp
+++ b/gtsam/slam/tests/testSerializationInSlam.cpp
@@ -22,6 +22,7 @@
 #include <gtsam/slam/SmartProjectionFactor.h>
 #include <gtsam/nonlinear/LevenbergMarquardtOptimizer.h>
 #include <gtsam/base/serializationTestHelpers.h>
+#include <gtsam/base/std_optional_serialization.h>
 
 #include <CppUnitLite/TestHarness.h>
 
diff --git a/gtsam/slam/tests/testSmartProjectionPoseFactor.cpp b/gtsam/slam/tests/testSmartProjectionPoseFactor.cpp
index ba5a53bbb..2eb799663 100644
--- a/gtsam/slam/tests/testSmartProjectionPoseFactor.cpp
+++ b/gtsam/slam/tests/testSmartProjectionPoseFactor.cpp
@@ -138,7 +138,7 @@ TEST( SmartProjectionPoseFactor, noiseless ) {
   factor.triangulateAndComputeE(actualE, values);
 
   // get point
-  boost::optional<Point3> point = factor.point();
+  auto point = factor.point();
   CHECK(point);
 
   // calculate numerical derivative with triangulated point
@@ -366,7 +366,7 @@ TEST( SmartProjectionPoseFactor, Factors ) {
   CHECK(smartFactor1->triangulateSafe(cameras));
   CHECK(!smartFactor1->isDegenerate());
   CHECK(!smartFactor1->isPointBehindCamera());
-  boost::optional<Point3> p = smartFactor1->point();
+  auto p = smartFactor1->point();
   CHECK(p);
   EXPECT(assert_equal(landmark1, *p));
 
diff --git a/gtsam/slam/tests/testSmartProjectionRigFactor.cpp b/gtsam/slam/tests/testSmartProjectionRigFactor.cpp
index 6d39eb5b0..2fa6e7290 100644
--- a/gtsam/slam/tests/testSmartProjectionRigFactor.cpp
+++ b/gtsam/slam/tests/testSmartProjectionRigFactor.cpp
@@ -166,7 +166,7 @@ TEST(SmartProjectionRigFactor, noiseless) {
   factor.triangulateAndComputeE(actualE, values);
 
   // get point
-  boost::optional<Point3> point = factor.point();
+  auto point = factor.point();
   CHECK(point);
 
   // calculate numerical derivative with triangulated point
@@ -508,7 +508,7 @@ TEST(SmartProjectionRigFactor, Factors) {
   CHECK(smartFactor1->triangulateSafe(cameras));
   CHECK(!smartFactor1->isDegenerate());
   CHECK(!smartFactor1->isPointBehindCamera());
-  boost::optional<Point3> p = smartFactor1->point();
+  auto p = smartFactor1->point();
   CHECK(p);
   EXPECT(assert_equal(landmark1, *p));
 
diff --git a/gtsam/slam/tests/testTriangulationFactor.cpp b/gtsam/slam/tests/testTriangulationFactor.cpp
index 42df4d8fe..bdfade5f2 100644
--- a/gtsam/slam/tests/testTriangulationFactor.cpp
+++ b/gtsam/slam/tests/testTriangulationFactor.cpp
@@ -91,7 +91,7 @@ TEST( triangulation, TriangulationFactorStereo ) {
   // compare same problem against expression factor
   Expression<StereoPoint2>::UnaryFunction<Point3>::type f =
       std::bind(&StereoCamera::project2, camera2, std::placeholders::_1,
-                boost::none, std::placeholders::_2);
+                nullptr, std::placeholders::_2);
   Expression<Point3> point_(pointKey);
   Expression<StereoPoint2> project2_(f, point_);
 
diff --git a/gtsam/symbolic/SymbolicFactorGraph.h b/gtsam/symbolic/SymbolicFactorGraph.h
index 1d4292cbf..219ba7bf5 100644
--- a/gtsam/symbolic/SymbolicFactorGraph.h
+++ b/gtsam/symbolic/SymbolicFactorGraph.h
@@ -49,8 +49,8 @@ namespace gtsam {
     /// The default ordering generation function
     static Ordering DefaultOrderingFunc(
         const FactorGraphType& graph,
-        boost::optional<const VariableIndex&> variableIndex) {
-      return Ordering::Colamd(*variableIndex);
+        std::optional<std::reference_wrapper<const VariableIndex>> variableIndex) {
+      return Ordering::Colamd((*variableIndex).get());
     }
   };
 
diff --git a/gtsam/symbolic/tests/testSymbolicBayesTree.cpp b/gtsam/symbolic/tests/testSymbolicBayesTree.cpp
index 0095c9293..f1cc6ee4f 100644
--- a/gtsam/symbolic/tests/testSymbolicBayesTree.cpp
+++ b/gtsam/symbolic/tests/testSymbolicBayesTree.cpp
@@ -213,7 +213,7 @@ TEST(BayesTree, shortcutCheck) {
   // Check if all the cached shortcuts are cleared
   rootClique->deleteCachedShortcuts();
   for (SymbolicBayesTree::sharedClique& clique : allCliques) {
-    bool notCleared = clique->cachedSeparatorMarginal().is_initialized();
+    bool notCleared = clique->cachedSeparatorMarginal().has_value();
     CHECK(notCleared == false);
   }
   EXPECT_LONGS_EQUAL(0, (long)rootClique->numCachedSeparatorMarginals());
diff --git a/gtsam_unstable/discrete/AllDiff.cpp b/gtsam_unstable/discrete/AllDiff.cpp
index bff524bc2..cf598b3f4 100644
--- a/gtsam_unstable/discrete/AllDiff.cpp
+++ b/gtsam_unstable/discrete/AllDiff.cpp
@@ -10,6 +10,7 @@
 #include <gtsam_unstable/discrete/Domain.h>
 
 #include <boost/make_shared.hpp>
+#include <optional>
 
 namespace gtsam {
 
@@ -64,7 +65,7 @@ bool AllDiff::ensureArcConsistency(Key j, Domains* domains) const {
   // a value in domains->at(j) that does not occur in any other connected domain.
   // If found, we make this a singleton...
   // TODO: make a new constraint where this really is true
-  boost::optional<Domain> maybeChanged = Dj.checkAllDiff(keys_, *domains);
+  std::optional<Domain> maybeChanged = Dj.checkAllDiff(keys_, *domains);
   if (maybeChanged) {
     Dj = *maybeChanged;
     return true;
diff --git a/gtsam_unstable/discrete/Domain.cpp b/gtsam_unstable/discrete/Domain.cpp
index cf0da42e7..f2b7d9f95 100644
--- a/gtsam_unstable/discrete/Domain.cpp
+++ b/gtsam_unstable/discrete/Domain.cpp
@@ -61,7 +61,7 @@ bool Domain::ensureArcConsistency(Key j, Domains* domains) const {
 }
 
 /* ************************************************************************* */
-boost::optional<Domain> Domain::checkAllDiff(const KeyVector keys,
+std::optional<Domain> Domain::checkAllDiff(const KeyVector keys,
                                              const Domains& domains) const {
   Key j = key();
   // for all values in this domain
@@ -74,7 +74,7 @@ boost::optional<Domain> Domain::checkAllDiff(const KeyVector keys,
     return Domain(this->discreteKey(), value);
   found:;
   }
-  return boost::none;  // we did not change it
+  return {};  // we did not change it
 }
 
 /* ************************************************************************* */
diff --git a/gtsam_unstable/discrete/Domain.h b/gtsam_unstable/discrete/Domain.h
index 1047101c5..5d96f0dc9 100644
--- a/gtsam_unstable/discrete/Domain.h
+++ b/gtsam_unstable/discrete/Domain.h
@@ -9,6 +9,7 @@
 
 #include <gtsam/discrete/DiscreteKey.h>
 #include <gtsam_unstable/discrete/Constraint.h>
+#include <optional>
 
 namespace gtsam {
 
@@ -100,7 +101,7 @@ class GTSAM_UNSTABLE_EXPORT Domain : public Constraint {
    * @param keys connected domains through alldiff
    * @param keys other domains
    */
-  boost::optional<Domain> checkAllDiff(const KeyVector keys,
+  std::optional<Domain> checkAllDiff(const KeyVector keys,
                                        const Domains& domains) const;
 
   /// Partially apply known values
diff --git a/gtsam_unstable/discrete/Scheduler.cpp b/gtsam_unstable/discrete/Scheduler.cpp
index b86df6c29..9543ab7cf 100644
--- a/gtsam_unstable/discrete/Scheduler.cpp
+++ b/gtsam_unstable/discrete/Scheduler.cpp
@@ -79,7 +79,7 @@ void Scheduler::addStudent(const string& studentName, const string& area1,
 
 /** get key for student and area, 0 is time slot itself */
 const DiscreteKey& Scheduler::key(size_t s,
-                                  boost::optional<size_t> area) const {
+                                  std::optional<size_t> area) const {
   return area ? students_[s].keys_[*area] : students_[s].key_;
 }
 
@@ -100,7 +100,7 @@ const string& Scheduler::studentArea(size_t i, size_t area) const {
 
 /** Add student-specific constraints to the graph */
 void Scheduler::addStudentSpecificConstraints(size_t i,
-                                              boost::optional<size_t> slot) {
+                                              std::optional<size_t> slot) {
   bool debug = ISDEBUG("Scheduler::buildGraph");
 
   assert(i < nrStudents());
diff --git a/gtsam_unstable/discrete/Scheduler.h b/gtsam_unstable/discrete/Scheduler.h
index 8d269e81a..f7b45d54a 100644
--- a/gtsam_unstable/discrete/Scheduler.h
+++ b/gtsam_unstable/discrete/Scheduler.h
@@ -108,7 +108,7 @@ class GTSAM_UNSTABLE_EXPORT Scheduler : public CSP {
 
   /** get key for student and area, 0 is time slot itself */
   const DiscreteKey& key(size_t s,
-                         boost::optional<size_t> area = boost::none) const;
+                         std::optional<size_t> area = {}) const;
 
   /** addStudent has to be called after adding slots and faculty */
   void addStudent(const std::string& studentName, const std::string& area1,
@@ -124,7 +124,7 @@ class GTSAM_UNSTABLE_EXPORT Scheduler : public CSP {
 
   /** Add student-specific constraints to the graph */
   void addStudentSpecificConstraints(
-      size_t i, boost::optional<size_t> slot = boost::none);
+      size_t i, std::optional<size_t> slot = {});
 
   /** Main routine that builds factor graph */
   void buildGraph(size_t mutexBound = 7);
diff --git a/gtsam_unstable/discrete/examples/schedulingExample.cpp b/gtsam_unstable/discrete/examples/schedulingExample.cpp
index bf5f2f25c..dd92b295d 100644
--- a/gtsam_unstable/discrete/examples/schedulingExample.cpp
+++ b/gtsam_unstable/discrete/examples/schedulingExample.cpp
@@ -12,7 +12,6 @@
 #include <gtsam/base/debug.h>
 #include <gtsam/base/timing.h>
 
-#include <boost/optional.hpp>
 #include <boost/format.hpp>
 
 #include <algorithm>
diff --git a/gtsam_unstable/discrete/examples/schedulingQuals12.cpp b/gtsam_unstable/discrete/examples/schedulingQuals12.cpp
index a15b6f922..8c4c0d728 100644
--- a/gtsam_unstable/discrete/examples/schedulingQuals12.cpp
+++ b/gtsam_unstable/discrete/examples/schedulingQuals12.cpp
@@ -12,7 +12,6 @@
 #include <gtsam/base/debug.h>
 #include <gtsam/base/timing.h>
 
-#include <boost/optional.hpp>
 #include <boost/format.hpp>
 
 #include <algorithm>
diff --git a/gtsam_unstable/discrete/examples/schedulingQuals13.cpp b/gtsam_unstable/discrete/examples/schedulingQuals13.cpp
index e888875a4..06276c516 100644
--- a/gtsam_unstable/discrete/examples/schedulingQuals13.cpp
+++ b/gtsam_unstable/discrete/examples/schedulingQuals13.cpp
@@ -12,7 +12,6 @@
 #include <gtsam/base/debug.h>
 #include <gtsam/base/timing.h>
 
-#include <boost/optional.hpp>
 #include <boost/format.hpp>
 
 #include <algorithm>
diff --git a/gtsam_unstable/discrete/tests/testScheduler.cpp b/gtsam_unstable/discrete/tests/testScheduler.cpp
index 3b0528360..f868abb5e 100644
--- a/gtsam_unstable/discrete/tests/testScheduler.cpp
+++ b/gtsam_unstable/discrete/tests/testScheduler.cpp
@@ -10,7 +10,6 @@
 #include <gtsam/base/timing.h>
 #include <gtsam_unstable/discrete/Scheduler.h>
 
-#include <boost/optional.hpp>
 
 using namespace std;
 using namespace gtsam;
diff --git a/gtsam_unstable/dynamics/PoseRTV.h b/gtsam_unstable/dynamics/PoseRTV.h
index c573de2b6..89ae59f9c 100644
--- a/gtsam_unstable/dynamics/PoseRTV.h
+++ b/gtsam_unstable/dynamics/PoseRTV.h
@@ -88,8 +88,8 @@ public:
 
   /** range between translations */
   double range(const PoseRTV& other,
-               OptionalJacobian<1,9> H1=boost::none,
-               OptionalJacobian<1,9> H2=boost::none) const;
+               OptionalJacobian<1,9> H1={},
+               OptionalJacobian<1,9> H2={}) const;
   /// @}
 
   /// @name IMU-specific
@@ -138,8 +138,8 @@ public:
    * Note: the transform jacobian convention is flipped
    */
   PoseRTV transformed_from(const Pose3& trans,
-      ChartJacobian Dglobal = boost::none,
-      OptionalJacobian<9, 6> Dtrans = boost::none) const;
+      ChartJacobian Dglobal = {},
+      OptionalJacobian<9, 6> Dtrans = {}) const;
 
   /// @}
   /// @name Utility functions
diff --git a/gtsam_unstable/dynamics/SimpleHelicopter.h b/gtsam_unstable/dynamics/SimpleHelicopter.h
index 3e4ad0d9f..9a536fba0 100644
--- a/gtsam_unstable/dynamics/SimpleHelicopter.h
+++ b/gtsam_unstable/dynamics/SimpleHelicopter.h
@@ -130,7 +130,7 @@ public:
     Vector pk_1 = muk_1 - 0.5*Pose3::adjointTranspose(-h_*xik_1, muk_1, D_adjThxik1_muk1);
 
     Matrix D_gravityBody_gk;
-    Point3 gravityBody = gk.rotation().unrotate(Point3(0.0, 0.0, -9.81*m_), D_gravityBody_gk, boost::none);
+    Point3 gravityBody = gk.rotation().unrotate(Point3(0.0, 0.0, -9.81*m_), D_gravityBody_gk, {});
     Vector f_ext = (Vector(6) << 0.0, 0.0, 0.0, gravityBody.x(), gravityBody.y(), gravityBody.z()).finished();
 
     Vector hx = pk - pk_1 - h_*Fu_ - h_*f_ext;
diff --git a/gtsam_unstable/geometry/Event.h b/gtsam_unstable/geometry/Event.h
index ddeda180e..a4055d038 100644
--- a/gtsam_unstable/geometry/Event.h
+++ b/gtsam_unstable/geometry/Event.h
@@ -55,7 +55,7 @@ class Event {
   Point3 location() const { return location_; }
 
   // TODO(frank) we really have to think of a better way to do linear arguments
-  double height(OptionalJacobian<1, 4> H = boost::none) const {
+  double height(OptionalJacobian<1, 4> H = {}) const {
     static const Matrix14 JacobianZ = (Matrix14() << 0, 0, 0, 1).finished();
     if (H) *H = JacobianZ;
     return location_.z();
@@ -101,8 +101,8 @@ class TimeOfArrival {
 
   /// Calculate time of arrival, with derivatives
   double operator()(const Event& event, const Point3& sensor,  //
-                    OptionalJacobian<1, 4> H1 = boost::none,   //
-                    OptionalJacobian<1, 3> H2 = boost::none) const {
+                    OptionalJacobian<1, 4> H1 = {},   //
+                    OptionalJacobian<1, 3> H2 = {}) const {
     Matrix13 D1, D2;
     double distance = gtsam::distance3(event.location(), sensor, D1, D2);
     if (H1)
diff --git a/gtsam_unstable/geometry/InvDepthCamera3.h b/gtsam_unstable/geometry/InvDepthCamera3.h
index 7e070ca72..8b2797938 100644
--- a/gtsam_unstable/geometry/InvDepthCamera3.h
+++ b/gtsam_unstable/geometry/InvDepthCamera3.h
@@ -12,7 +12,6 @@
 #pragma once
 
 #include <cmath>
-#include <boost/optional.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <gtsam/base/Vector.h>
 #include <gtsam/base/Matrix.h>
@@ -101,7 +100,7 @@ public:
     }
     else {
       gtsam::Matrix J2;
-      gtsam::Point2 uv= camera.project(landmark,H1, J2, boost::none);
+      gtsam::Point2 uv= camera.project(landmark,H1, J2, {});
       if (H1) {
         *H1 = (*H1) * I_6x6;
       }
diff --git a/gtsam_unstable/geometry/Pose3Upright.h b/gtsam_unstable/geometry/Pose3Upright.h
index 321eba934..1c205c7fb 100644
--- a/gtsam_unstable/geometry/Pose3Upright.h
+++ b/gtsam_unstable/geometry/Pose3Upright.h
@@ -98,12 +98,12 @@ public:
   static Pose3Upright Identity() { return Pose3Upright(); }
 
   /// inverse transformation with derivatives
-  Pose3Upright inverse(OptionalJacobian<4,4> H1=boost::none) const;
+  Pose3Upright inverse(OptionalJacobian<4,4> H1={}) const;
 
   ///compose this transformation onto another (first *this and then p2)
   Pose3Upright compose(const Pose3Upright& p2,
-      OptionalJacobian<4,4> H1=boost::none,
-      OptionalJacobian<4,4> H2=boost::none) const;
+      OptionalJacobian<4,4> H1={},
+      OptionalJacobian<4,4> H2={}) const;
 
   /// compose syntactic sugar
   inline Pose3Upright operator*(const Pose3Upright& T) const { return compose(T); }
@@ -113,8 +113,8 @@ public:
    * as well as optionally the derivatives
    */
   Pose3Upright between(const Pose3Upright& p2,
-      OptionalJacobian<4,4> H1=boost::none,
-      OptionalJacobian<4,4> H2=boost::none) const;
+      OptionalJacobian<4,4> H1={},
+      OptionalJacobian<4,4> H2={}) const;
 
   /// @}
   /// @name Lie Group
diff --git a/gtsam_unstable/geometry/tests/testEvent.cpp b/gtsam_unstable/geometry/tests/testEvent.cpp
index f1bbc3970..25a05793d 100644
--- a/gtsam_unstable/geometry/tests/testEvent.cpp
+++ b/gtsam_unstable/geometry/tests/testEvent.cpp
@@ -65,11 +65,11 @@ TEST(Event, Derivatives) {
   Matrix13 actualH2;
   kToa(exampleEvent, microphoneAt0, actualH1, actualH2);
   Matrix expectedH1 = numericalDerivative11<double, Event>(
-      std::bind(kToa, std::placeholders::_1, microphoneAt0, boost::none, boost::none),
+      std::bind(kToa, std::placeholders::_1, microphoneAt0, nullptr, nullptr),
       exampleEvent);
   EXPECT(assert_equal(expectedH1, actualH1, 1e-8));
   Matrix expectedH2 = numericalDerivative11<double, Point3>(
-      std::bind(kToa, exampleEvent, std::placeholders::_1, boost::none, boost::none),
+      std::bind(kToa, exampleEvent, std::placeholders::_1, nullptr, nullptr),
       microphoneAt0);
   EXPECT(assert_equal(expectedH2, actualH2, 1e-8));
 }
diff --git a/gtsam_unstable/gtsam_unstable.i b/gtsam_unstable/gtsam_unstable.i
index 6ce7be20a..5cd7e0da2 100644
--- a/gtsam_unstable/gtsam_unstable.i
+++ b/gtsam_unstable/gtsam_unstable.i
@@ -179,7 +179,7 @@ class SimWall2D {
   gtsam::Point2 midpoint() const;
 
   bool intersects(const gtsam::SimWall2D& wall) const;
-  //   bool intersects(const gtsam::SimWall2D& wall, boost::optional<gtsam::Point2&> pt=boost::none) const;
+  //   bool intersects(const gtsam::SimWall2D& wall, gtsam::Point2* pt = nullptr) const;
 
   gtsam::Point2 norm() const;
   gtsam::Rot2 reflection(const gtsam::Point2& init, const gtsam::Point2& intersection) const;
diff --git a/gtsam_unstable/nonlinear/ConcurrentBatchFilter.cpp b/gtsam_unstable/nonlinear/ConcurrentBatchFilter.cpp
index 83d0ab719..d6456cd51 100644
--- a/gtsam_unstable/nonlinear/ConcurrentBatchFilter.cpp
+++ b/gtsam_unstable/nonlinear/ConcurrentBatchFilter.cpp
@@ -119,7 +119,7 @@ bool ConcurrentBatchFilter::equals(const ConcurrentFilter& rhs, double tol) cons
 
 /* ************************************************************************* */
 ConcurrentBatchFilter::Result ConcurrentBatchFilter::update(const NonlinearFactorGraph& newFactors, const Values& newTheta,
-    const boost::optional<FastList<Key> >& keysToMove, const boost::optional< std::vector<size_t> >& removeFactorIndices) {
+    const std::optional<FastList<Key> >& keysToMove, const std::optional< std::vector<size_t> >& removeFactorIndices) {
 
   gttic(update);
 
@@ -358,7 +358,7 @@ void ConcurrentBatchFilter::removeFactors(const std::vector<size_t>& slots) {
 }
 
 /* ************************************************************************* */
-void ConcurrentBatchFilter::reorder(const boost::optional<FastList<Key> >& keysToMove) {
+void ConcurrentBatchFilter::reorder(const std::optional<FastList<Key> >& keysToMove) {
 
   // COLAMD groups will be used to place marginalize keys in Group 0, and everything else in Group 1
   if(keysToMove && keysToMove->size() > 0) {
diff --git a/gtsam_unstable/nonlinear/ConcurrentBatchFilter.h b/gtsam_unstable/nonlinear/ConcurrentBatchFilter.h
index 7e35476b9..b88d5c739 100644
--- a/gtsam_unstable/nonlinear/ConcurrentBatchFilter.h
+++ b/gtsam_unstable/nonlinear/ConcurrentBatchFilter.h
@@ -124,7 +124,7 @@ public:
    * @param removeFactorIndices An optional set of indices corresponding to the factors you want to remove from the graph
    */
   virtual Result update(const NonlinearFactorGraph& newFactors = NonlinearFactorGraph(), const Values& newTheta = Values(),
-      const boost::optional<FastList<Key> >& keysToMove = boost::none, const boost::optional< std::vector<size_t> >& removeFactorIndices = boost::none);
+      const std::optional<FastList<Key> >& keysToMove = {}, const std::optional< std::vector<size_t> >& removeFactorIndices = {});
 
   /**
    * Perform any required operations before the synchronization process starts.
@@ -200,7 +200,7 @@ private:
   void removeFactors(const std::vector<size_t>& slots);
 
   /** Use colamd to update into an efficient ordering */
-  void reorder(const boost::optional<FastList<Key> >& keysToMove = boost::none);
+  void reorder(const std::optional<FastList<Key> >& keysToMove = {});
 
   /** Marginalize out the set of requested variables from the filter, caching them for the smoother
    *  This effectively moves the separator.
diff --git a/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.cpp b/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.cpp
index 75d491bde..816917eb5 100644
--- a/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.cpp
+++ b/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.cpp
@@ -47,7 +47,7 @@ bool ConcurrentBatchSmoother::equals(const ConcurrentSmoother& rhs, double tol)
 
 /* ************************************************************************* */
 ConcurrentBatchSmoother::Result ConcurrentBatchSmoother::update(const NonlinearFactorGraph& newFactors, const Values& newTheta,
-    const boost::optional< std::vector<size_t> >& removeFactorIndices) {
+    const std::optional< std::vector<size_t> >& removeFactorIndices) {
 
   gttic(update);
 
diff --git a/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.h b/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.h
index 51d3284a4..38b39594b 100644
--- a/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.h
+++ b/gtsam_unstable/nonlinear/ConcurrentBatchSmoother.h
@@ -118,7 +118,7 @@ public:
    * and additionally, variables that were already in the system must not be included here.
    */
   virtual Result update(const NonlinearFactorGraph& newFactors = NonlinearFactorGraph(), const Values& newTheta = Values(),
-      const boost::optional< std::vector<size_t> >& removeFactorIndices = boost::none);
+      const std::optional< std::vector<size_t> >& removeFactorIndices = {});
 
   /**
    * Perform any required operations before the synchronization process starts.
diff --git a/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.cpp b/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.cpp
index b9cf66a97..6ef4f9066 100644
--- a/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.cpp
+++ b/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.cpp
@@ -43,7 +43,7 @@ bool ConcurrentIncrementalFilter::equals(const ConcurrentFilter& rhs, double tol
 
 /* ************************************************************************* */
 ConcurrentIncrementalFilter::Result ConcurrentIncrementalFilter::update(const NonlinearFactorGraph& newFactors, const Values& newTheta,
-    const boost::optional<FastList<Key> >& keysToMove, const boost::optional< FactorIndices >& removeFactorIndices) {
+    const std::optional<FastList<Key> >& keysToMove, const std::optional< FactorIndices >& removeFactorIndices) {
 
   gttic(update);
 
@@ -63,7 +63,7 @@ ConcurrentIncrementalFilter::Result ConcurrentIncrementalFilter::update(const No
   }
 
   // Generate ordering constraints that force the 'keys to move' to the end
-  boost::optional<FastMap<Key,int> > orderingConstraints = boost::none;
+  std::optional<FastMap<Key,int> > orderingConstraints = {};
   if(keysToMove && keysToMove->size() > 0) {
     orderingConstraints = FastMap<Key,int>();
     int group = 1;
@@ -86,10 +86,10 @@ ConcurrentIncrementalFilter::Result ConcurrentIncrementalFilter::update(const No
 
   // Create the set of linear keys that iSAM2 should hold constant
   // iSAM2 takes care of this for us; no need to specify additional noRelin keys
-  boost::optional<FastList<Key> > noRelinKeys = boost::none;
+  std::optional<FastList<Key> > noRelinKeys = {};
 
   // Mark additional keys between the 'keys to move' and the leaves
-  boost::optional<FastList<Key> > additionalKeys = boost::none;
+  std::optional<FastList<Key> > additionalKeys = {};
   if(keysToMove && keysToMove->size() > 0) {
     std::set<Key> markedKeys;
     for(Key key: *keysToMove) {
@@ -211,7 +211,7 @@ void ConcurrentIncrementalFilter::synchronize(const NonlinearFactorGraph& smooth
 
   // Remove the old factors on the separator and insert the new ones
   FactorIndices removeFactors(currentSmootherSummarizationSlots_.begin(), currentSmootherSummarizationSlots_.end());
-  ISAM2Result result = isam2_.update(currentSmootherSummarization, Values(), removeFactors, boost::none, noRelinKeys, boost::none, false);
+  ISAM2Result result = isam2_.update(currentSmootherSummarization, Values(), removeFactors, {}, noRelinKeys, {}, false);
   currentSmootherSummarizationSlots_ = result.newFactorsIndices;
 
   // Set the previous smoother summarization to the current smoother summarization and clear the smoother shortcut
diff --git a/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.h b/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.h
index eb1174749..8e1409523 100644
--- a/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.h
+++ b/gtsam_unstable/nonlinear/ConcurrentIncrementalFilter.h
@@ -123,8 +123,8 @@ public:
    * @param removeFactorIndices An optional set of indices corresponding to the factors you want to remove from the graph
    */
   Result update(const NonlinearFactorGraph& newFactors = NonlinearFactorGraph(), const Values& newTheta = Values(),
-      const boost::optional<FastList<Key> >& keysToMove = boost::none,
-      const boost::optional< FactorIndices >& removeFactorIndices = boost::none);
+      const std::optional<FastList<Key> >& keysToMove = {},
+      const std::optional< FactorIndices >& removeFactorIndices = {});
 
   /**
    * Perform any required operations before the synchronization process starts.
diff --git a/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.cpp b/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.cpp
index 3886d0e42..5c08eced5 100644
--- a/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.cpp
+++ b/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.cpp
@@ -45,7 +45,7 @@ bool ConcurrentIncrementalSmoother::equals(const ConcurrentSmoother& rhs, double
 
 /* ************************************************************************* */
 ConcurrentIncrementalSmoother::Result ConcurrentIncrementalSmoother::update(const NonlinearFactorGraph& newFactors, const Values& newTheta,
-    const boost::optional<FactorIndices>& removeFactorIndices) {
+    const std::optional<FactorIndices>& removeFactorIndices) {
 
   gttic(update);
 
diff --git a/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.h b/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.h
index a27751561..92d8c462a 100644
--- a/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.h
+++ b/gtsam_unstable/nonlinear/ConcurrentIncrementalSmoother.h
@@ -109,7 +109,7 @@ public:
    * and additionally, variables that were already in the system must not be included here.
    */
   Result update(const NonlinearFactorGraph& newFactors = NonlinearFactorGraph(), const Values& newTheta = Values(),
-      const boost::optional<FactorIndices>& removeFactorIndices = boost::none);
+      const std::optional<FactorIndices>& removeFactorIndices = {});
 
   /**
    * Perform any required operations before the synchronization process starts.
diff --git a/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.cpp b/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.cpp
index d29dfe8ca..52e56260d 100644
--- a/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.cpp
+++ b/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.cpp
@@ -76,7 +76,7 @@ FixedLagSmoother::Result IncrementalFixedLagSmoother::update(
   }
 
   FastVector<size_t> removedFactors;
-  boost::optional<FastMap<Key, int> > constrainedKeys = boost::none;
+  std::optional<FastMap<Key, int> > constrainedKeys = {};
 
   // Update the Timestamps associated with the factor keys
   updateKeyTimestampMap(timestamps);
@@ -126,7 +126,7 @@ FixedLagSmoother::Result IncrementalFixedLagSmoother::update(
 
   // Update iSAM2
   isamResult_ = isam_.update(newFactors, newTheta,
-      factorsToRemove, constrainedKeys, boost::none, additionalMarkedKeys);
+      factorsToRemove, constrainedKeys, {}, additionalMarkedKeys);
 
   if (debug) {
     PrintSymbolicTree(isam_,
@@ -175,7 +175,7 @@ void IncrementalFixedLagSmoother::eraseKeysBefore(double timestamp) {
 /* ************************************************************************* */
 void IncrementalFixedLagSmoother::createOrderingConstraints(
     const KeyVector& marginalizableKeys,
-    boost::optional<FastMap<Key, int> >& constrainedKeys) const {
+    std::optional<FastMap<Key, int> >& constrainedKeys) const {
   if (marginalizableKeys.size() > 0) {
     constrainedKeys = FastMap<Key, int>();
     // Generate ordering constraints so that the marginalizable variables will be eliminated first
diff --git a/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.h b/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.h
index 4079dbb23..b2910b139 100644
--- a/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.h
+++ b/gtsam_unstable/nonlinear/IncrementalFixedLagSmoother.h
@@ -137,7 +137,7 @@ protected:
 
   /** Fill in an iSAM2 ConstrainedKeys structure such that the provided keys are eliminated before all others */
   void createOrderingConstraints(const KeyVector& marginalizableKeys,
-      boost::optional<FastMap<Key, int> >& constrainedKeys) const;
+      std::optional<FastMap<Key, int> >& constrainedKeys) const;
 
 private:
   /** Private methods for printing debug information */
diff --git a/gtsam_unstable/partition/FindSeparator-inl.h b/gtsam_unstable/partition/FindSeparator-inl.h
index 0e4950b79..45868e78e 100644
--- a/gtsam_unstable/partition/FindSeparator-inl.h
+++ b/gtsam_unstable/partition/FindSeparator-inl.h
@@ -13,6 +13,7 @@
 #include <stdexcept>
 #include <iostream>
 #include <vector>
+#include <optional>
 #include <boost/tuple/tuple.hpp>
 #include <boost/shared_array.hpp>
 
@@ -237,7 +238,7 @@ namespace gtsam { namespace partition {
 
   /* ************************************************************************* */
   template<class GenericGraph>
-  boost::optional<MetisResult> separatorPartitionByMetis(const GenericGraph& graph,
+  std::optional<MetisResult> separatorPartitionByMetis(const GenericGraph& graph,
     const std::vector<size_t>& keys, WorkSpace& workspace, bool verbose) {
     // create a metis graph
     size_t numKeys = keys.size();
@@ -252,7 +253,7 @@ namespace gtsam { namespace partition {
     size_t sepsize;
     sharedInts part;
     boost::tie(sepsize, part) = separatorMetis(numKeys, xadj, adjncy, adjwgt, verbose);
-    if (!sepsize)  return boost::optional<MetisResult>();
+    if (!sepsize)  return std::optional<MetisResult>();
 
     // convert the 0-1-2 from Metis to 1-2-0, so that the separator is 0, as later
     //  we will have more submaps
@@ -291,7 +292,7 @@ namespace gtsam { namespace partition {
 
   /* *************************************************************************/
   template<class GenericGraph>
-  boost::optional<MetisResult> edgePartitionByMetis(const GenericGraph& graph,
+  std::optional<MetisResult> edgePartitionByMetis(const GenericGraph& graph,
    const std::vector<size_t>& keys, WorkSpace& workspace, bool verbose) {
 
     // a small hack for handling the camera1-camera2 case used in the unit tests
@@ -443,15 +444,15 @@ namespace gtsam { namespace partition {
 
   /* ************************************************************************* */
   template<class GenericGraph>
-  boost::optional<MetisResult> findPartitoning(const GenericGraph& graph, const std::vector<size_t>& keys,
+  std::optional<MetisResult> findPartitoning(const GenericGraph& graph, const std::vector<size_t>& keys,
       WorkSpace& workspace, bool verbose,
-      const boost::optional<std::vector<Symbol> >& int2symbol, const bool reduceGraph) {
-    boost::optional<MetisResult> result;
+      const std::optional<std::vector<Symbol> >& int2symbol, const bool reduceGraph) {
+    std::optional<MetisResult> result;
     GenericGraph reducedGraph;
     std::vector<size_t> keyToPartition;
     std::vector<size_t> cameraKeys, landmarkKeys;
     if (reduceGraph) {
-      if (!int2symbol.is_initialized())
+      if (!int2symbol.has_value())
         throw std::invalid_argument("findSeparator: int2symbol must be valid!");
 
       // find out all the landmark keys, which are to be eliminated
@@ -474,9 +475,9 @@ namespace gtsam { namespace partition {
     }  else // call Metis to partition the graph to A, B, C
       result = separatorPartitionByMetis(graph, keys, workspace, verbose);
 
-    if (!result.is_initialized()) {
+    if (!result.has_value()) {
       std::cout << "metis failed!" << std::endl;
-      return boost::none;
+      return {};
     }
 
     if (reduceGraph) {
@@ -491,10 +492,10 @@ namespace gtsam { namespace partition {
   template<class GenericGraph>
   int findSeparator(const GenericGraph& graph, const std::vector<size_t>& keys,
       const int minNodesPerMap, WorkSpace& workspace, bool verbose,
-      const boost::optional<std::vector<Symbol> >& int2symbol, const bool reduceGraph,
+      const std::optional<std::vector<Symbol> >& int2symbol, const bool reduceGraph,
       const int minNrConstraintsPerCamera, const int minNrConstraintsPerLandmark) {
 
-    boost::optional<MetisResult> result = findPartitoning(graph, keys, workspace,
+    std::optional<MetisResult> result = findPartitoning(graph, keys, workspace,
       verbose, int2symbol, reduceGraph);
 
     // find the island in A and B, and make them separated submaps
diff --git a/gtsam_unstable/partition/FindSeparator.h b/gtsam_unstable/partition/FindSeparator.h
index f4342695b..3093fae4d 100644
--- a/gtsam_unstable/partition/FindSeparator.h
+++ b/gtsam_unstable/partition/FindSeparator.h
@@ -10,7 +10,6 @@
 
 #include <map>
 #include <vector>
-#include <boost/optional.hpp>
 #include <gtsam/inference/Key.h>
 #include <gtsam/inference/Symbol.h>
 
@@ -31,7 +30,7 @@ namespace gtsam { namespace partition {
    * the size of dictionary mush be equal to the number of variables in the original graph (the largest one)
    */
   template<class GenericGraph>
-  boost::optional<MetisResult> separatorPartitionByMetis(const GenericGraph& graph, const std::vector<size_t>& keys,
+  std::optional<MetisResult> separatorPartitionByMetis(const GenericGraph& graph, const std::vector<size_t>& keys,
       WorkSpace& workspace, bool verbose);
 
   /**
@@ -40,7 +39,7 @@ namespace gtsam { namespace partition {
    */
   template<class GenericGraph>
   int findSeparator(const GenericGraph& graph, const std::vector<size_t>& keys,
-      const int minNodesPerMap, WorkSpace& workspace, bool verbose, const boost::optional<std::vector<Symbol> >& int2symbol,
+      const int minNodesPerMap, WorkSpace& workspace, bool verbose, const std::optional<std::vector<Symbol> >& int2symbol,
       const bool reduceGraph, const int minNrConstraintsPerCamera, const int minNrConstraintsPerLandmark);
 
 }} //namespace
diff --git a/gtsam_unstable/partition/tests/testFindSeparator.cpp b/gtsam_unstable/partition/tests/testFindSeparator.cpp
index 49796f80d..b086be7ff 100644
--- a/gtsam_unstable/partition/tests/testFindSeparator.cpp
+++ b/gtsam_unstable/partition/tests/testFindSeparator.cpp
@@ -29,10 +29,10 @@ TEST ( Partition, separatorPartitionByMetis )
   std::vector<size_t> keys{0, 1, 2, 3, 4};
 
   WorkSpace workspace(5);
-  boost::optional<MetisResult> actual = separatorPartitionByMetis<GenericGraph2D>(graph, keys,
+  std::optional<MetisResult> actual = separatorPartitionByMetis<GenericGraph2D>(graph, keys,
    workspace, true);
 
-  CHECK(actual.is_initialized());
+  CHECK(actual.has_value());
   vector<size_t> A_expected{0, 3}; // frontal
   vector<size_t> B_expected{2, 4}; // frontal
   vector<size_t> C_expected{1};    // separator
@@ -54,10 +54,10 @@ TEST ( Partition, separatorPartitionByMetis2 )
   std::vector<size_t> keys{1, 2, 3, 5, 6};
 
   WorkSpace workspace(8);
-  boost::optional<MetisResult> actual = separatorPartitionByMetis<GenericGraph2D>(graph, keys,
+  std::optional<MetisResult> actual = separatorPartitionByMetis<GenericGraph2D>(graph, keys,
    workspace, true);
 
-  CHECK(actual.is_initialized());
+  CHECK(actual.has_value());
   vector<size_t> A_expected{1, 5}; // frontal
   vector<size_t> B_expected{3, 6}; // frontal
   vector<size_t> C_expected{2};    // separator
@@ -77,10 +77,10 @@ TEST ( Partition, edgePartitionByMetis )
   std::vector<size_t> keys{0, 1, 2, 3};
 
   WorkSpace workspace(6);
-  boost::optional<MetisResult> actual = edgePartitionByMetis<GenericGraph3D>(graph, keys,
+  std::optional<MetisResult> actual = edgePartitionByMetis<GenericGraph3D>(graph, keys,
    workspace, true);
 
-  CHECK(actual.is_initialized());
+  CHECK(actual.has_value());
   vector<size_t> A_expected{0, 1}; // frontal
   vector<size_t> B_expected{2, 3}; // frontal
   vector<size_t> C_expected;    // separator
@@ -108,9 +108,9 @@ TEST ( Partition, edgePartitionByMetis2 )
   std::vector<size_t> keys{0, 1, 2, 3, 4};
 
   WorkSpace workspace(6);
-  boost::optional<MetisResult> actual = edgePartitionByMetis<GenericGraph3D>(graph, keys,
+  std::optional<MetisResult> actual = edgePartitionByMetis<GenericGraph3D>(graph, keys,
    workspace, true);
-  CHECK(actual.is_initialized());
+  CHECK(actual.has_value());
   vector<size_t> A_expected{0, 1}; // frontal
   vector<size_t> B_expected{2, 3, 4}; // frontal
   vector<size_t> C_expected;    // separator
@@ -135,7 +135,7 @@ TEST ( Partition, findSeparator )
   int minNodesPerMap = -1;
   bool reduceGraph = false;
   int numSubmaps = findSeparator<GenericGraph2D>(graph, keys, minNodesPerMap, workspace,
-    false, boost::none, reduceGraph, 0, 0);
+    false, {}, reduceGraph, 0, 0);
   LONGS_EQUAL(2, numSubmaps);
   LONGS_EQUAL(5, workspace.partitionTable.size());
   LONGS_EQUAL(1, workspace.partitionTable[0]);
@@ -161,7 +161,7 @@ TEST ( Partition, findSeparator2 )
   int minNodesPerMap = -1;
   bool reduceGraph = false;
   int numSubmaps = findSeparator<GenericGraph2D>(graph, keys, minNodesPerMap, workspace,
-    false, boost::none, reduceGraph, 0, 0);
+    false, {}, reduceGraph, 0, 0);
   LONGS_EQUAL(2, numSubmaps);
   LONGS_EQUAL(8, workspace.partitionTable.size());
   LONGS_EQUAL(-1,workspace.partitionTable[0]);
diff --git a/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel.h b/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel.h
index 529af878d..c6c960ac1 100644
--- a/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel.h
+++ b/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel.h
@@ -28,7 +28,6 @@
 #include <gtsam/base/numericalDerivative.h>
 
 #include <boost/bind/bind.hpp>
-#include <boost/optional.hpp>
 
 #include <ostream>
 
@@ -106,8 +105,8 @@ private:
 
   Matrix Jacobian_wrt_t0_Overall_;
 
-  boost::optional<IMUBIAS> Bias_initial_; // Bias used when pre-integrating IMU measurements
-  boost::optional<POSE> body_P_sensor_;   // The pose of the sensor in the body frame
+  std::optional<IMUBIAS> Bias_initial_; // Bias used when pre-integrating IMU measurements
+  std::optional<POSE> body_P_sensor_;   // The pose of the sensor in the body frame
 
 public:
 	
@@ -126,7 +125,7 @@ public:
       double dt12, const Vector world_g, const Vector world_rho,
       const Vector& world_omega_earth, const noiseModel::Gaussian::shared_ptr& model_equivalent,
       const Matrix& Jacobian_wrt_t0_Overall,
-      boost::optional<IMUBIAS> Bias_initial = boost::none, boost::optional<POSE> body_P_sensor = boost::none) :
+      std::optional<IMUBIAS> Bias_initial = {}, std::optional<POSE> body_P_sensor = {}) :
         Base(model_equivalent, Pose1, Vel1, IMUBias1, Pose2, Vel2),
         delta_pos_in_t0_(delta_pos_in_t0), delta_vel_in_t0_(delta_vel_in_t0), delta_angles_(delta_angles),
         dt12_(dt12), world_g_(world_g), world_rho_(world_rho), world_omega_earth_(world_omega_earth), Jacobian_wrt_t0_Overall_(Jacobian_wrt_t0_Overall),
@@ -385,7 +384,7 @@ public:
       const Vector& delta_pos_in_t0, const Vector3& delta_angles,
       double dt12, const Vector world_g, const Vector world_rho,
       const Vector& world_omega_earth, const Matrix& Jacobian_wrt_t0_Overall,
-      const boost::optional<IMUBIAS>& Bias_initial = boost::none) {
+      const std::optional<IMUBIAS>& Bias_initial = {}) {
 
 
     // Correct delta_pos_in_t0_ using (Bias1 - Bias_t0)
@@ -414,7 +413,7 @@ public:
   static inline VELOCITY PredictVelocityFromPreIntegration(const POSE& Pose1, const VELOCITY& Vel1, const IMUBIAS& Bias1,
       const Vector& delta_vel_in_t0, double dt12, const Vector world_g, const Vector world_rho,
       const Vector& world_omega_earth, const Matrix& Jacobian_wrt_t0_Overall,
-      const boost::optional<IMUBIAS>& Bias_initial = boost::none) {
+      const std::optional<IMUBIAS>& Bias_initial = {}) {
 
     // Correct delta_vel_in_t0_ using (Bias1 - Bias_t0)
     Vector delta_BiasAcc  = Bias1.accelerometer();
@@ -436,7 +435,7 @@ public:
       const Vector& delta_pos_in_t0, const Vector& delta_vel_in_t0, const Vector3& delta_angles,
       double dt12, const Vector world_g, const Vector world_rho,
       const Vector& world_omega_earth, const Matrix& Jacobian_wrt_t0_Overall,
-      const boost::optional<IMUBIAS>& Bias_initial = boost::none) {
+      const std::optional<IMUBIAS>& Bias_initial = {}) {
 
     Pose2 = PredictPoseFromPreIntegration(Pose1, Vel1, Bias1, delta_pos_in_t0, delta_angles, dt12, world_g, world_rho, world_omega_earth, Jacobian_wrt_t0_Overall, Bias_initial);
     Vel2  = PredictVelocityFromPreIntegration(Pose1, Vel1, Bias1, delta_vel_in_t0, dt12, world_g, world_rho, world_omega_earth, Jacobian_wrt_t0_Overall, Bias_initial);
@@ -447,7 +446,7 @@ public:
       Vector& delta_pos_in_t0, Vector3& delta_angles, Vector& delta_vel_in_t0, double& delta_t,
       const noiseModel::Gaussian::shared_ptr& model_continuous_overall,
       Matrix& EquivCov_Overall, Matrix& Jacobian_wrt_t0_Overall, const IMUBIAS Bias_t0 = IMUBIAS(),
-      boost::optional<POSE> p_body_P_sensor = boost::none){
+      std::optional<POSE> p_body_P_sensor = {}){
     // Note: all delta terms refer to an IMU\sensor system at t0
     // Note: Earth-related terms are not accounted here but are incorporated in predict functions.
 
diff --git a/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel_NoBias.h b/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel_NoBias.h
index f3e27f7e5..f4c20a2ba 100644
--- a/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel_NoBias.h
+++ b/gtsam_unstable/slam/EquivInertialNavFactor_GlobalVel_NoBias.h
@@ -27,7 +27,6 @@
 // Using numerical derivative to calculate d(Pose3::Expmap)/dw
 #include <gtsam/base/numericalDerivative.h>
 
-#include <boost/optional.hpp>
 
 #include <ostream>
 
@@ -105,7 +104,7 @@ private:
 
   Matrix Jacobian_wrt_t0_Overall_;
 
-  boost::optional<POSE> body_P_sensor_;   // The pose of the sensor in the body frame
+  std::optional<POSE> body_P_sensor_;   // The pose of the sensor in the body frame
 
 public:
 
@@ -124,7 +123,7 @@ public:
       double dt12, const Vector world_g, const Vector world_rho,
       const Vector& world_omega_earth, const noiseModel::Gaussian::shared_ptr& model_equivalent,
       const Matrix& Jacobian_wrt_t0_Overall,
-      boost::optional<POSE> body_P_sensor = boost::none) :
+      std::optional<POSE> body_P_sensor = {}) :
         Base(model_equivalent, Pose1, Vel1, Pose2, Vel2),
         delta_pos_in_t0_(delta_pos_in_t0), delta_vel_in_t0_(delta_vel_in_t0), delta_angles_(delta_angles),
         dt12_(dt12), world_g_(world_g), world_rho_(world_rho), world_omega_earth_(world_omega_earth), Jacobian_wrt_t0_Overall_(Jacobian_wrt_t0_Overall),
@@ -352,7 +351,7 @@ public:
       Vector& delta_pos_in_t0, Vector3& delta_angles, Vector& delta_vel_in_t0, double& delta_t,
       const noiseModel::Gaussian::shared_ptr& model_continuous_overall,
       Matrix& EquivCov_Overall, Matrix& Jacobian_wrt_t0_Overall,
-      boost::optional<POSE> p_body_P_sensor = boost::none){
+      std::optional<POSE> p_body_P_sensor = {}){
     // Note: all delta terms refer to an IMU\sensor system at t0
     // Note: Earth-related terms are not accounted here but are incorporated in predict functions.
 
diff --git a/gtsam_unstable/slam/InertialNavFactor_GlobalVelocity.h b/gtsam_unstable/slam/InertialNavFactor_GlobalVelocity.h
index 40fc9da25..508f1f294 100644
--- a/gtsam_unstable/slam/InertialNavFactor_GlobalVelocity.h
+++ b/gtsam_unstable/slam/InertialNavFactor_GlobalVelocity.h
@@ -27,7 +27,6 @@
 #include <gtsam/base/numericalDerivative.h>
 
 #include <boost/bind/bind.hpp>
-#include <boost/optional.hpp>
 
 #include <ostream>
 
@@ -92,7 +91,7 @@ private:
   Vector world_rho_;
   Vector world_omega_earth_;
 
-  boost::optional<POSE> body_P_sensor_; // The pose of the sensor in the body frame
+  std::optional<POSE> body_P_sensor_; // The pose of the sensor in the body frame
 
 public:
 
@@ -108,7 +107,7 @@ public:
   /** Constructor */
   InertialNavFactor_GlobalVelocity(const Key& Pose1, const Key& Vel1, const Key& IMUBias1, const Key& Pose2, const Key& Vel2,
       const Vector& measurement_acc, const Vector& measurement_gyro, const double measurement_dt, const Vector world_g, const Vector world_rho,
-      const Vector& world_omega_earth, const noiseModel::Gaussian::shared_ptr& model_continuous, boost::optional<POSE> body_P_sensor = boost::none) :
+      const Vector& world_omega_earth, const noiseModel::Gaussian::shared_ptr& model_continuous, std::optional<POSE> body_P_sensor = {}) :
         Base(calc_descrete_noise_model(model_continuous, measurement_dt ),
             Pose1, Vel1, IMUBias1, Pose2, Vel2), measurement_acc_(measurement_acc), measurement_gyro_(measurement_gyro),
             dt_(measurement_dt), world_g_(world_g), world_rho_(world_rho), world_omega_earth_(world_omega_earth), body_P_sensor_(body_P_sensor) {  }
diff --git a/gtsam_unstable/slam/LocalOrientedPlane3Factor.cpp b/gtsam_unstable/slam/LocalOrientedPlane3Factor.cpp
index 8854df5c7..010e62218 100644
--- a/gtsam_unstable/slam/LocalOrientedPlane3Factor.cpp
+++ b/gtsam_unstable/slam/LocalOrientedPlane3Factor.cpp
@@ -43,7 +43,7 @@ Vector LocalOrientedPlane3Factor::evaluateError(const Pose3& wTwi,
 
   // Calculate the error between measured and estimated planes in sensor frame.
   const Vector3 err = measured_p_.errorVector(i_plane,
-    boost::none, (H1 || H2 || H3) ? &error_H_predicted : nullptr);
+    {}, (H1 || H2 || H3) ? &error_H_predicted : nullptr);
 
   // Apply the chain rule to calculate the derivatives.
   if (H1) {
diff --git a/gtsam_unstable/slam/MultiProjectionFactor.h b/gtsam_unstable/slam/MultiProjectionFactor.h
index f64568118..5ba25abd2 100644
--- a/gtsam_unstable/slam/MultiProjectionFactor.h
+++ b/gtsam_unstable/slam/MultiProjectionFactor.h
@@ -22,7 +22,6 @@
 
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam/geometry/PinholeCamera.h>
-#include <boost/optional.hpp>
 #include "gtsam/geometry/Cal3_S2.h"
 
 namespace gtsam {
@@ -39,7 +38,7 @@ namespace gtsam {
     // Keep a copy of measurement and calibration for I/O
     Vector measured_;                    ///< 2D measurement for each of the n views
     boost::shared_ptr<CALIBRATION> K_;  ///< shared pointer to calibration object
-    boost::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
+    std::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
 
 
     // verbosity handling for Cheirality Exceptions
@@ -72,7 +71,7 @@ namespace gtsam {
      */
     MultiProjectionFactor(const Vector& measured, const SharedNoiseModel& model,
         KeySet poseKeys, Key pointKey, const boost::shared_ptr<CALIBRATION>& K,
-        boost::optional<POSE> body_P_sensor = boost::none) :
+        std::optional<POSE> body_P_sensor = {}) :
           Base(model), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
           throwCheirality_(false), verboseCheirality_(false) {
       keys_.assign(poseKeys.begin(), poseKeys.end());
@@ -94,7 +93,7 @@ namespace gtsam {
     MultiProjectionFactor(const Vector& measured, const SharedNoiseModel& model,
         KeySet poseKeys, Key pointKey, const boost::shared_ptr<CALIBRATION>& K,
         bool throwCheirality, bool verboseCheirality,
-        boost::optional<POSE> body_P_sensor = boost::none) :
+        std::optional<POSE> body_P_sensor = {}) :
           Base(model), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
           throwCheirality_(throwCheirality), verboseCheirality_(verboseCheirality) {}
 
diff --git a/gtsam_unstable/slam/PoseBetweenFactor.h b/gtsam_unstable/slam/PoseBetweenFactor.h
index 14a18d938..9e275116b 100644
--- a/gtsam_unstable/slam/PoseBetweenFactor.h
+++ b/gtsam_unstable/slam/PoseBetweenFactor.h
@@ -37,7 +37,7 @@ namespace gtsam {
     typedef NoiseModelFactorN<POSE, POSE> Base;
 
     POSE measured_; /** The measurement */
-    boost::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
+    std::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
 
     /** concept check by type */
     GTSAM_CONCEPT_TESTABLE_TYPE(POSE)
@@ -55,7 +55,7 @@ namespace gtsam {
 
     /** Constructor */
     PoseBetweenFactor(Key key1, Key key2, const POSE& measured,
-        const SharedNoiseModel& model, boost::optional<POSE> body_P_sensor = boost::none) :
+        const SharedNoiseModel& model, std::optional<POSE> body_P_sensor = {}) :
       Base(model, key1, key2), measured_(measured), body_P_sensor_(body_P_sensor) {
     }
 
diff --git a/gtsam_unstable/slam/PosePriorFactor.h b/gtsam_unstable/slam/PosePriorFactor.h
index ac199588b..4e55bd649 100644
--- a/gtsam_unstable/slam/PosePriorFactor.h
+++ b/gtsam_unstable/slam/PosePriorFactor.h
@@ -34,7 +34,7 @@ namespace gtsam {
     typedef NoiseModelFactorN<POSE> Base;
 
     POSE prior_; /** The measurement */
-    boost::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
+    std::optional<POSE> body_P_sensor_; ///< The pose of the sensor in the body frame
 
     /** concept check by type */
     GTSAM_CONCEPT_TESTABLE_TYPE(POSE)
@@ -54,7 +54,7 @@ namespace gtsam {
 
     /** Constructor */
     PosePriorFactor(Key key, const POSE& prior, const SharedNoiseModel& model,
-        boost::optional<POSE> body_P_sensor = boost::none) :
+        std::optional<POSE> body_P_sensor = {}) :
       Base(model, key), prior_(prior), body_P_sensor_(body_P_sensor) {
     }
 
diff --git a/gtsam_unstable/slam/ProjectionFactorPPP.h b/gtsam_unstable/slam/ProjectionFactorPPP.h
index 9ef11f022..9c09257d3 100644
--- a/gtsam_unstable/slam/ProjectionFactorPPP.h
+++ b/gtsam_unstable/slam/ProjectionFactorPPP.h
@@ -21,7 +21,6 @@
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam/geometry/PinholeCamera.h>
 #include <gtsam/geometry/Cal3_S2.h>
-#include <boost/optional.hpp>
 
 namespace gtsam {
 
@@ -130,13 +129,13 @@ namespace gtsam {
           if(H1 || H2 || H3) {
             Matrix H0, H02;
             PinholeCamera<CALIBRATION> camera(pose.compose(transform, H0, H02), *K_);
-            Point2 reprojectionError(camera.project(point, H1, H3, boost::none) - measured_);
+            Point2 reprojectionError(camera.project(point, H1, H3, {}) - measured_);
             *H2 = *H1 * H02;
             *H1 = *H1 * H0;
             return reprojectionError;
           } else {
             PinholeCamera<CALIBRATION> camera(pose.compose(transform), *K_);
-            return camera.project(point, H1, H3, boost::none) - measured_;
+            return camera.project(point, H1, H3, {}) - measured_;
           }
       } catch( CheiralityException& e) {
         if (H1) *H1 = Matrix::Zero(2,6);
diff --git a/gtsam_unstable/slam/ProjectionFactorPPPC.h b/gtsam_unstable/slam/ProjectionFactorPPPC.h
index 7159cd5e0..b4288d7a0 100644
--- a/gtsam_unstable/slam/ProjectionFactorPPPC.h
+++ b/gtsam_unstable/slam/ProjectionFactorPPPC.h
@@ -23,7 +23,6 @@
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam_unstable/dllexport.h>
 
-#include <boost/optional.hpp>
 
 namespace gtsam {
 
diff --git a/gtsam_unstable/slam/ProjectionFactorRollingShutter.cpp b/gtsam_unstable/slam/ProjectionFactorRollingShutter.cpp
index 003f2f921..beeafecf4 100644
--- a/gtsam_unstable/slam/ProjectionFactorRollingShutter.cpp
+++ b/gtsam_unstable/slam/ProjectionFactorRollingShutter.cpp
@@ -31,7 +31,7 @@ Vector ProjectionFactorRollingShutter::evaluateError(
         gtsam::Matrix HbodySensor;
         PinholeCamera<Cal3_S2> camera(
             pose.compose(*body_P_sensor_, HbodySensor), *K_);
-        Point2 reprojectionError(camera.project(point, Hprj, H3, boost::none) -
+        Point2 reprojectionError(camera.project(point, Hprj, H3, {}) -
                                  measured_);
         if (H1) *H1 = Hprj * HbodySensor * (*H1);
         if (H2) *H2 = Hprj * HbodySensor * (*H2);
@@ -42,7 +42,7 @@ Vector ProjectionFactorRollingShutter::evaluateError(
       }
     } else {
       PinholeCamera<Cal3_S2> camera(pose, *K_);
-      Point2 reprojectionError(camera.project(point, Hprj, H3, boost::none) -
+      Point2 reprojectionError(camera.project(point, Hprj, H3, {}) -
                                measured_);
       if (H1) *H1 = Hprj * (*H1);
       if (H2) *H2 = Hprj * (*H2);
diff --git a/gtsam_unstable/slam/ProjectionFactorRollingShutter.h b/gtsam_unstable/slam/ProjectionFactorRollingShutter.h
index bbf108ecc..2d2c2c6c2 100644
--- a/gtsam_unstable/slam/ProjectionFactorRollingShutter.h
+++ b/gtsam_unstable/slam/ProjectionFactorRollingShutter.h
@@ -23,7 +23,6 @@
 #include <gtsam/nonlinear/NonlinearFactor.h>
 #include <gtsam_unstable/dllexport.h>
 
-#include <boost/optional.hpp>
 
 namespace gtsam {
 
@@ -49,7 +48,7 @@ class GTSAM_UNSTABLE_EXPORT ProjectionFactorRollingShutter
   double alpha_;     ///< interpolation parameter in [0,1] corresponding to the
                      ///< point2 measurement
   boost::shared_ptr<Cal3_S2> K_;  ///< shared pointer to calibration object
-  boost::optional<Pose3>
+  std::optional<Pose3>
       body_P_sensor_;  ///< The pose of the sensor in the body frame
 
   // verbosity handling for Cheirality Exceptions
@@ -96,7 +95,7 @@ class GTSAM_UNSTABLE_EXPORT ProjectionFactorRollingShutter
       const Point2& measured, double alpha, const SharedNoiseModel& model,
       Key poseKey_a, Key poseKey_b, Key pointKey,
       const boost::shared_ptr<Cal3_S2>& K,
-      boost::optional<Pose3> body_P_sensor = boost::none)
+      std::optional<Pose3> body_P_sensor = {})
       : Base(model, poseKey_a, poseKey_b, pointKey),
         measured_(measured),
         alpha_(alpha),
@@ -127,7 +126,7 @@ class GTSAM_UNSTABLE_EXPORT ProjectionFactorRollingShutter
       Key poseKey_a, Key poseKey_b, Key pointKey,
       const boost::shared_ptr<Cal3_S2>& K, bool throwCheirality,
       bool verboseCheirality,
-      boost::optional<Pose3> body_P_sensor = boost::none)
+      std::optional<Pose3> body_P_sensor = {})
       : Base(model, poseKey_a, poseKey_b, pointKey),
         measured_(measured),
         alpha_(alpha),
diff --git a/gtsam_unstable/slam/SmartRangeFactor.h b/gtsam_unstable/slam/SmartRangeFactor.h
index 301508c0f..17270f392 100644
--- a/gtsam_unstable/slam/SmartRangeFactor.h
+++ b/gtsam_unstable/slam/SmartRangeFactor.h
@@ -19,6 +19,7 @@
 #include <stdexcept>
 #include <string>
 #include <vector>
+#include <optional>
 
 namespace gtsam {
 
@@ -105,8 +106,8 @@ class SmartRangeFactor: public NoiseModelFactor {
     }
 
     Circle2 circle1 = circles.front();
-    boost::optional<Point2> best_fh;
-    auto bestCircle2 = boost::make_optional(false, circle1);  // fixes issue #38
+    std::optional<Point2> best_fh;
+    std::optional<Circle2> bestCircle2 = std::nullopt;  // fixes issue #38
 
     // loop over all circles
     for (const Circle2& it : circles) {
@@ -115,7 +116,7 @@ class SmartRangeFactor: public NoiseModelFactor {
       if (d < 1e-9)
         continue;  // skip circles that are in the same location
       // Find f and h, the intersection points in normalized circles
-      boost::optional<Point2> fh = circleCircleIntersection(
+      std::optional<Point2> fh = circleCircleIntersection(
           circle1.radius / d, it.radius / d);
       // Check if this pair is better by checking h = fh->y()
       // if h is large, the intersections are well defined.
diff --git a/gtsam_unstable/slam/SmartStereoProjectionFactor.h b/gtsam_unstable/slam/SmartStereoProjectionFactor.h
index a9caf0c4c..1a2a648e3 100644
--- a/gtsam_unstable/slam/SmartStereoProjectionFactor.h
+++ b/gtsam_unstable/slam/SmartStereoProjectionFactor.h
@@ -31,7 +31,8 @@
 #include <gtsam_unstable/dllexport.h>
 
 #include <boost/make_shared.hpp>
-#include <boost/optional.hpp>
+#include <boost/serialization/optional.hpp>
+#include <optional>
 #include <vector>
 
 namespace gtsam {
@@ -87,7 +88,7 @@ public:
    */
   SmartStereoProjectionFactor(const SharedNoiseModel& sharedNoiseModel,
       const SmartStereoProjectionParams& params = SmartStereoProjectionParams(),
-      const boost::optional<Pose3> body_P_sensor = boost::none) :
+      const std::optional<Pose3> body_P_sensor = {}) :
       Base(sharedNoiseModel, body_P_sensor), //
       params_(params), //
       result_(TriangulationResult::Degenerate()) {
@@ -415,7 +416,7 @@ public:
    * to transform it to \f$ (h(x)-z)^2/\sigma^2 \f$, and then multiply by 0.5.
    */
   double totalReprojectionError(const Cameras& cameras,
-      boost::optional<Point3> externalPoint = boost::none) const {
+      std::optional<Point3> externalPoint = {}) const {
 
     if (externalPoint)
       result_ = TriangulationResult(*externalPoint);
diff --git a/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.cpp b/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.cpp
index c28cb25a1..4f6ef18ab 100644
--- a/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.cpp
+++ b/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.cpp
@@ -26,7 +26,7 @@ namespace gtsam {
 SmartStereoProjectionPoseFactor::SmartStereoProjectionPoseFactor(
     const SharedNoiseModel& sharedNoiseModel,
     const SmartStereoProjectionParams& params,
-    const boost::optional<Pose3>& body_P_sensor)
+    const std::optional<Pose3>& body_P_sensor)
     : Base(sharedNoiseModel, params, body_P_sensor) {}
 
 void SmartStereoProjectionPoseFactor::add(
diff --git a/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.h b/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.h
index ad09cd207..7295413ca 100644
--- a/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.h
+++ b/gtsam_unstable/slam/SmartStereoProjectionPoseFactor.h
@@ -69,7 +69,7 @@ class GTSAM_UNSTABLE_EXPORT SmartStereoProjectionPoseFactor
   SmartStereoProjectionPoseFactor(
       const SharedNoiseModel& sharedNoiseModel,
       const SmartStereoProjectionParams& params = SmartStereoProjectionParams(),
-      const boost::optional<Pose3>& body_P_sensor = boost::none);
+      const std::optional<Pose3>& body_P_sensor = {});
 
   /** Virtual destructor */
   ~SmartStereoProjectionPoseFactor() override = default;
diff --git a/gtsam_unstable/slam/TransformBtwRobotsUnaryFactor.h b/gtsam_unstable/slam/TransformBtwRobotsUnaryFactor.h
index 5745536e0..d2d28ef9b 100644
--- a/gtsam_unstable/slam/TransformBtwRobotsUnaryFactor.h
+++ b/gtsam_unstable/slam/TransformBtwRobotsUnaryFactor.h
@@ -165,8 +165,8 @@ namespace gtsam {
       T currA_T_currB_pred;
       if (H) {
         Matrix H_compose, H_between1;
-        T orgA_T_currB = orgA_T_orgB.compose(orgB_T_currB, H_compose, boost::none);
-        currA_T_currB_pred = orgA_T_currA.between(orgA_T_currB, boost::none, H_between1);
+        T orgA_T_currB = orgA_T_orgB.compose(orgB_T_currB, H_compose, {});
+        currA_T_currB_pred = orgA_T_currA.between(orgA_T_currB, {}, H_between1);
         (*H)[0] = H_compose * H_between1;
       }
       else {
diff --git a/gtsam_unstable/slam/tests/testProjectionFactorRollingShutter.cpp b/gtsam_unstable/slam/tests/testProjectionFactorRollingShutter.cpp
index 3c7c39f48..31a385695 100644
--- a/gtsam_unstable/slam/tests/testProjectionFactorRollingShutter.cpp
+++ b/gtsam_unstable/slam/tests/testProjectionFactorRollingShutter.cpp
@@ -342,24 +342,24 @@ TEST(ProjectionFactorRollingShutter, cheirality) {
         std::function<Vector(const Pose3&, const Pose3&, const Point3&)>(
             std::bind(&ProjectionFactorRollingShutter::evaluateError, &factor,
                       std::placeholders::_1, std::placeholders::_2,
-                      std::placeholders::_3, boost::none, boost::none,
-                      boost::none)),
+                      std::placeholders::_3, {}, {},
+                      {})),
         pose1, pose2, point);
 
     Matrix H2Expected = numericalDerivative32<Vector, Pose3, Pose3, Point3>(
         std::function<Vector(const Pose3&, const Pose3&, const Point3&)>(
             std::bind(&ProjectionFactorRollingShutter::evaluateError, &factor,
                       std::placeholders::_1, std::placeholders::_2,
-                      std::placeholders::_3, boost::none, boost::none,
-                      boost::none)),
+                      std::placeholders::_3, {}, {},
+                      {})),
         pose1, pose2, point);
 
     Matrix H3Expected = numericalDerivative33<Vector, Pose3, Pose3, Point3>(
         std::function<Vector(const Pose3&, const Pose3&, const Point3&)>(
             std::bind(&ProjectionFactorRollingShutter::evaluateError, &factor,
                       std::placeholders::_1, std::placeholders::_2,
-                      std::placeholders::_3, boost::none, boost::none,
-                      boost::none)),
+                      std::placeholders::_3, {}, {},
+                      {})),
         pose1, pose2, point);
 
     CHECK(assert_equal(H1Expected, H1Actual, 1e-5));
diff --git a/gtsam_unstable/slam/tests/testSmartProjectionPoseFactorRollingShutter.cpp b/gtsam_unstable/slam/tests/testSmartProjectionPoseFactorRollingShutter.cpp
index cad1feae1..098d33744 100644
--- a/gtsam_unstable/slam/tests/testSmartProjectionPoseFactorRollingShutter.cpp
+++ b/gtsam_unstable/slam/tests/testSmartProjectionPoseFactorRollingShutter.cpp
@@ -664,7 +664,7 @@ TEST(SmartProjectionPoseFactorRollingShutter, hessian_simple_2poses) {
   EXPECT(smartFactor1->triangulateSafe(cameras));
   EXPECT(!smartFactor1->isDegenerate());
   EXPECT(!smartFactor1->isPointBehindCamera());
-  boost::optional<Point3> p = smartFactor1->point();
+  std::optional<Point3> p = smartFactor1->point();
   EXPECT(p);
   EXPECT(assert_equal(landmark1, *p));
 
diff --git a/python/gtsam/preamble/geometry.h b/python/gtsam/preamble/geometry.h
index bd0441d06..f36221d38 100644
--- a/python/gtsam/preamble/geometry.h
+++ b/python/gtsam/preamble/geometry.h
@@ -12,13 +12,6 @@
  */
 #include <pybind11/stl.h>
 
-// Support for binding boost::optional types in C++11.
-// https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html
-namespace pybind11 { namespace detail {
-    template <typename T>
-    struct type_caster<boost::optional<T>> : optional_caster<boost::optional<T>> {};
-}}
-
 PYBIND11_MAKE_OPAQUE(
     std::vector<gtsam::Point2, Eigen::aligned_allocator<gtsam::Point2>>);
 PYBIND11_MAKE_OPAQUE(gtsam::Point2Pairs);
diff --git a/tests/testExpressionFactor.cpp b/tests/testExpressionFactor.cpp
index bb35ada19..5a3678392 100644
--- a/tests/testExpressionFactor.cpp
+++ b/tests/testExpressionFactor.cpp
@@ -204,7 +204,7 @@ TEST(ExpressionFactor, Binary) {
   expected22 << 1, 0, 0, 1;
 
   // Check matrices
-  boost::optional<Binary::Record*> r = trace.record<Binary::Record>();
+  std::optional<Binary::Record*> r = trace.record<Binary::Record>();
   CHECK(r);
   EXPECT(assert_equal(expected25, (Matrix ) (*r)->dTdA1, 1e-9));
   EXPECT(assert_equal(expected22, (Matrix ) (*r)->dTdA2, 1e-9));
@@ -257,7 +257,7 @@ TEST(ExpressionFactor, Shallow) {
   expected23 << 1, 0, 0, 0, 1, 0;
 
   // Check matrices
-  boost::optional<Unary::Record*> r = trace.record<Unary::Record>();
+  std::optional<Unary::Record*> r = trace.record<Unary::Record>();
   CHECK(r);
   EXPECT(assert_equal(expected23, (Matrix)(*r)->dTdA1, 1e-9));
 
@@ -623,7 +623,7 @@ TEST(ExpressionFactor, MultiplyWithInverseFunction) {
   CHECK(assert_equal(A * b, Ab));
   CHECK(assert_equal(
       numericalDerivative11<Vector3, Point2>(
-          std::bind(f, std::placeholders::_1, b, boost::none, boost::none), a),
+        [&](const Point2& a) { return f(a, b, {}, {}); }, a),
       H1));
 
   Values values;
diff --git a/tests/testSerializationSlam.cpp b/tests/testSerializationSlam.cpp
index ea7038635..f986d812a 100644
--- a/tests/testSerializationSlam.cpp
+++ b/tests/testSerializationSlam.cpp
@@ -50,6 +50,7 @@
 #include <gtsam/linear/GaussianISAM.h>
 #include <gtsam/inference/Symbol.h>
 #include <gtsam/base/serializationTestHelpers.h>
+#include <gtsam/base/std_optional_serialization.h>
 
 #include <boost/archive/xml_iarchive.hpp>
 #include <boost/serialization/export.hpp>
diff --git a/tests/testSimulated3D.cpp b/tests/testSimulated3D.cpp
index 2bc381f7a..cfe00856a 100644
--- a/tests/testSimulated3D.cpp
+++ b/tests/testSimulated3D.cpp
@@ -46,7 +46,7 @@ TEST( simulated3D, Values )
 TEST( simulated3D, Dprior )
 {
   Point3 x(1,-9, 7);
-  Matrix numerical = numericalDerivative11<Point3, Point3>(std::bind(simulated3D::prior, std::placeholders::_1, boost::none),x);
+  Matrix numerical = numericalDerivative11<Point3, Point3>(std::bind(simulated3D::prior, std::placeholders::_1, nullptr),x);
   Matrix computed;
   simulated3D::prior(x,computed);
   EXPECT(assert_equal(numerical,computed,1e-9));
@@ -60,12 +60,12 @@ TEST( simulated3D, DOdo )
   simulated3D::odo(x1, x2, H1, H2);
   Matrix A1 = numericalDerivative21<Point3, Point3, Point3>(
       std::bind(simulated3D::odo, std::placeholders::_1, std::placeholders::_2,
-                boost::none, boost::none),
+                nullptr, nullptr),
       x1, x2);
   EXPECT(assert_equal(A1, H1, 1e-9));
   Matrix A2 = numericalDerivative22<Point3, Point3, Point3>(
       std::bind(simulated3D::odo, std::placeholders::_1, std::placeholders::_2,
-                boost::none, boost::none),
+                nullptr, nullptr),
       x1, x2);
   EXPECT(assert_equal(A2, H2, 1e-9));
 }