diff --git a/.github/workflows/macos-linux-pip.yml b/.github/workflows/macos-linux-pip.yml
index f372a769..e755d8bd 100644
--- a/.github/workflows/macos-linux-pip.yml
+++ b/.github/workflows/macos-linux-pip.yml
@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        os: ["ubuntu-latest", "macos-latest"]
+        os: ["ubuntu-latest"] # , "macos-latest"]
         python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
     steps:
       - uses: actions/checkout@v4
diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
new file mode 100644
index 00000000..52b45d9f
--- /dev/null
+++ b/.github/workflows/nix.yml
@@ -0,0 +1,19 @@
+name: "CI - Nix"
+
+on:
+  push:
+
+jobs:
+  nix:
+    runs-on: "${{ matrix.os }}-latest"
+    strategy:
+      matrix:
+        os: [ubuntu, macos]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: cachix/install-nix-action@v27
+      - uses: cachix/cachix-action@v15
+        with:
+          name: gepetto
+          authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+      - run: nix build -L
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 661f5051..684efb6f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,7 +2,7 @@ ci:
   autoupdate_branch: devel
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.3.5
+  rev: v0.8.2
   hooks:
   - id: ruff
     args:
@@ -14,18 +14,19 @@ repos:
   hooks:
   - id: cmake-format
 - repo: https://github.com/pappasam/toml-sort
-  rev: v0.23.1
+  rev: v0.24.2
   hooks:
   - id: toml-sort-fix
     exclude: poetry.lock
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.3
+  rev: v19.1.4
   hooks:
   - id: clang-format
     args:
     - --style=Google
+    exclude: python/test/sandbox/test.ipynb
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.6.0
+  rev: v5.0.0
   hooks:
   - id: check-added-large-files
   - id: check-ast
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ddd9de5f..665cc1cb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.0] - 2024-12-05
+
+- :warning: BREAKING: switch from boost smart pointers to std ones
+- setup nix
+- setup mergify
+
 ## [1.4.1] - 2024-04-12
 
 - tests: fix use of np.random in tests
@@ -174,7 +180,8 @@ Changes since v0.2.0:
 
 - Initial release
 
-[Unreleased]: https://github.com/loco-3d/ndcurves/compare/v1.4.1...HEAD
+[Unreleased]: https://github.com/loco-3d/ndcurves/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/loco-3d/ndcurves/compare/v1.4.1...v2.0.0
 [1.4.1]: https://github.com/loco-3d/ndcurves/compare/v1.4.0...v1.4.1
 [1.4.0]: https://github.com/loco-3d/ndcurves/compare/v1.3.1...v1.4.0
 [1.3.1]: https://github.com/loco-3d/ndcurves/compare/v1.3.0...v1.3.1
diff --git a/cmake b/cmake
index f4af8f79..29c0eb4e 160000
--- a/cmake
+++ b/cmake
@@ -1 +1 @@
-Subproject commit f4af8f7988760c8695c5366ea83862f7e8756512
+Subproject commit 29c0eb4e659304f44d55a0389e2749812d858659
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 00000000..14d6a05c
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,58 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1733312601,
+        "narHash": "sha256-4pDvzqnegAfRkPwO3wmwBhVi/Sye1mzps0zHWYnP88c=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "205b12d8b7cd4802fbcb8e8ef6a0f1408781a4f9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1733380312,
+        "narHash": "sha256-ywntxT10Om755wkB9tYgJwEwELQZKYAO5WcNuHv1vjI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "a772498086eac57d97065a980a21fc0f304e3192",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1733096140,
+        "narHash": "sha256-1qRH7uAUsyQI7R1Uwl4T+XvdNv778H0Nb5njNrqvylY=",
+        "type": "tarball",
+        "url": "https://github.com/NixOS/nixpkgs/archive/5487e69da40cbd611ab2cadee0b4637225f7cfae.tar.gz"
+      },
+      "original": {
+        "type": "tarball",
+        "url": "https://github.com/NixOS/nixpkgs/archive/5487e69da40cbd611ab2cadee0b4637225f7cfae.tar.gz"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 00000000..1e19e554
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,39 @@
+{
+  description = "Library for creating smooth cubic splines";
+
+  inputs = {
+    flake-parts.url = "github:hercules-ci/flake-parts";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    inputs:
+    inputs.flake-parts.lib.mkFlake { inherit inputs; } {
+      systems = inputs.nixpkgs.lib.systems.flakeExposed;
+      perSystem =
+        { pkgs, self', ... }:
+        {
+          apps.default = {
+            type = "app";
+            program = pkgs.python3.withPackages (_: [ self'.packages.default ]);
+          };
+          devShells.default = pkgs.mkShell { inputsFrom = [ self'.packages.default ]; };
+          packages = {
+            default = self'.packages.ndcurves;
+            ndcurves = pkgs.python3Packages.ndcurves.overrideAttrs (_: {
+              src = pkgs.lib.fileset.toSource {
+                root = ./.;
+                fileset = pkgs.lib.fileset.unions [
+                  ./CMakeLists.txt
+                  ./doc
+                  ./include
+                  ./package.xml
+                  ./python
+                  ./tests
+                ];
+              };
+            });
+          };
+        };
+    };
+}
diff --git a/include/ndcurves/bernstein.h b/include/ndcurves/bernstein.h
index fcab1df1..c8fedafe 100644
--- a/include/ndcurves/bernstein.h
+++ b/include/ndcurves/bernstein.h
@@ -49,7 +49,7 @@ struct Bern {
     if (!(u >= 0. && u <= 1.)) {
       throw std::invalid_argument("u needs to be betwen 0 and 1.");
     }
-    return bin_m_i_ * (pow(u, i_)) * pow((1 - u), m_minus_i);
+    return bin_m_i_ * (pow(u, i_))*pow((1 - u), m_minus_i);
   }
 
   /// \brief Check if actual Bernstein polynomial and other are approximately
diff --git a/include/ndcurves/bezier_curve.h b/include/ndcurves/bezier_curve.h
index 921269b4..d07ed7a9 100644
--- a/include/ndcurves/bezier_curve.h
+++ b/include/ndcurves/bezier_curve.h
@@ -38,7 +38,7 @@ struct bezier_curve : public curve_abc<Time, Numeric, Safe, Point> {
   typedef std::vector<point_t, Eigen::aligned_allocator<point_t> > t_point_t;
   typedef typename t_point_t::const_iterator cit_point_t;
   typedef bezier_curve<Time, Numeric, Safe, Point> bezier_curve_t;
-  typedef boost::shared_ptr<bezier_curve_t> bezier_curve_ptr_t;
+  typedef std::shared_ptr<bezier_curve_t> bezier_curve_ptr_t;
   typedef piecewise_curve<Time, Numeric, Safe, point_t, point_t, bezier_curve_t>
       piecewise_curve_t;
   typedef curve_abc<Time, Numeric, Safe, point_t> curve_abc_t;  // parent class
diff --git a/include/ndcurves/curve_abc.h b/include/ndcurves/curve_abc.h
index a0ab3843..616e6384 100644
--- a/include/ndcurves/curve_abc.h
+++ b/include/ndcurves/curve_abc.h
@@ -11,9 +11,8 @@
 #ifndef _STRUCT_CURVE_ABC
 #define _STRUCT_CURVE_ABC
 
-#include <boost/serialization/shared_ptr.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
 #include <functional>
+#include <memory>
 
 #include "MathDefs.h"
 #include "serialization/archive.hpp"
@@ -43,7 +42,7 @@ struct curve_abc : public serialization::Serializable {
       curve_t;  // parent class
   typedef curve_abc<Time, Numeric, Safe, point_derivate_t>
       curve_derivate_t;  // parent class
-  typedef boost::shared_ptr<curve_t> curve_ptr_t;
+  typedef std::shared_ptr<curve_t> curve_ptr_t;
 
   /* Constructors - destructors */
  public:
diff --git a/include/ndcurves/exact_cubic.h b/include/ndcurves/exact_cubic.h
index e9302132..ea040891 100644
--- a/include/ndcurves/exact_cubic.h
+++ b/include/ndcurves/exact_cubic.h
@@ -116,8 +116,8 @@ struct exact_cubic : public piecewise_curve<Time, Numeric, Safe, Point> {
   std::size_t getNumberSplines() { return this->getNumberCurves(); }
 
   spline_t getSplineAt(std::size_t index) {
-    boost::shared_ptr<spline_t> s_ptr =
-        boost::dynamic_pointer_cast<spline_t>(this->curves_.at(index));
+    std::shared_ptr<spline_t> s_ptr =
+        std::dynamic_pointer_cast<spline_t>(this->curves_.at(index));
     if (s_ptr)
       return *s_ptr;
     else
diff --git a/include/ndcurves/fwd.h b/include/ndcurves/fwd.h
index fb4125e7..e2921a4a 100644
--- a/include/ndcurves/fwd.h
+++ b/include/ndcurves/fwd.h
@@ -10,7 +10,7 @@
 #ifndef CURVES_FWD_H
 #define CURVES_FWD_H
 #include <Eigen/Dense>
-#include <boost/smart_ptr/shared_ptr.hpp>
+#include <memory>
 #include <vector>
 
 namespace ndcurves {
@@ -94,11 +94,11 @@ typedef curve_abc<double, double, true, transform_t, point6_t>
                   // (return dimension are fixed)
 
 // shared pointer to abstract types:
-typedef boost::shared_ptr<curve_abc_t> curve_ptr_t;
-typedef boost::shared_ptr<curve_3_t> curve3_ptr_t;
-typedef boost::shared_ptr<curve_rotation_t> curve_rotation_ptr_t;
-typedef boost::shared_ptr<curve_translation_t> curve_translation_ptr_t;
-typedef boost::shared_ptr<curve_SE3_t> curve_SE3_ptr_t;
+typedef std::shared_ptr<curve_abc_t> curve_ptr_t;
+typedef std::shared_ptr<curve_3_t> curve3_ptr_t;
+typedef std::shared_ptr<curve_rotation_t> curve_rotation_ptr_t;
+typedef std::shared_ptr<curve_translation_t> curve_translation_ptr_t;
+typedef std::shared_ptr<curve_SE3_t> curve_SE3_ptr_t;
 
 // definition of all curves class with pointX as return type:
 typedef polynomial<double, double, true, pointX_t, t_pointX_t> polynomial_t;
diff --git a/include/ndcurves/piecewise_curve.h b/include/ndcurves/piecewise_curve.h
index 42d130fd..7c14f1a4 100644
--- a/include/ndcurves/piecewise_curve.h
+++ b/include/ndcurves/piecewise_curve.h
@@ -9,8 +9,8 @@
 #define _CLASS_PIECEWISE_CURVE
 
 #include <boost/serialization/vector.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
 #include <fstream>
+#include <memory>
 #include <sstream>
 
 #include "curve_abc.h"
@@ -46,7 +46,7 @@ struct piecewise_curve
   typedef curve_abc<Time, Numeric, Safe, point_t, point_derivate_t>
       base_curve_t;           // parent class
   typedef CurveType curve_t;  // contained curves base class
-  typedef boost::shared_ptr<curve_t> curve_ptr_t;
+  typedef std::shared_ptr<curve_t> curve_ptr_t;
   typedef typename std::vector<curve_ptr_t> t_curve_ptr_t;
   typedef typename std::vector<Time> t_time_t;
   typedef piecewise_curve<Time, Numeric, Safe, Point, Point_derivate, CurveType>
@@ -54,7 +54,7 @@ struct piecewise_curve
   typedef piecewise_curve<Time, Numeric, Safe, Point_derivate, Point_derivate,
                           typename CurveType::curve_derivate_t>
       piecewise_curve_derivate_t;
-  typedef boost::shared_ptr<typename piecewise_curve_derivate_t::curve_t>
+  typedef std::shared_ptr<typename piecewise_curve_derivate_t::curve_t>
       curve_derivate_ptr_t;
 
  public:
@@ -174,7 +174,7 @@ struct piecewise_curve
 
   template <typename Curve>
   void add_curve(const Curve& curve) {
-    curve_ptr_t curve_ptr = boost::make_shared<Curve>(curve);
+    curve_ptr_t curve_ptr = std::make_shared<Curve>(curve);
     add_curve_ptr(curve_ptr);
   }
 
diff --git a/include/ndcurves/se3_curve.h b/include/ndcurves/se3_curve.h
index 363e0206..847a63cd 100644
--- a/include/ndcurves/se3_curve.h
+++ b/include/ndcurves/se3_curve.h
@@ -41,9 +41,9 @@ struct SE3Curve : public curve_abc<Time, Numeric, Safe,
   typedef curve_abc<Time, Numeric, Safe, matrix3_t, point3_t>
       curve_rotation_t;  // templated class used for the rotation (return
                          // dimension are fixed)
-  typedef boost::shared_ptr<curve_X_t> curve_ptr_t;
-  typedef boost::shared_ptr<curve_rotation_t> curve_rotation_ptr_t;
-  typedef boost::shared_ptr<curve_translation_t> curve_translation_ptr_t;
+  typedef std::shared_ptr<curve_X_t> curve_ptr_t;
+  typedef std::shared_ptr<curve_rotation_t> curve_rotation_ptr_t;
+  typedef std::shared_ptr<curve_translation_t> curve_translation_ptr_t;
 
   typedef SO3Linear<Time, Numeric, Safe> SO3Linear_t;
   typedef polynomial<Time, Numeric, Safe, pointX_t> polynomial_t;
diff --git a/include/ndcurves/serialization/curves.hpp b/include/ndcurves/serialization/curves.hpp
index 416ab8c1..445e7532 100644
--- a/include/ndcurves/serialization/curves.hpp
+++ b/include/ndcurves/serialization/curves.hpp
@@ -12,7 +12,6 @@
  */
 
 #include <boost/serialization/shared_ptr.hpp>
-#include <boost/shared_ptr.hpp>
 
 #include "ndcurves/bezier_curve.h"
 #include "ndcurves/constant_curve.h"
diff --git a/package.xml b/package.xml
index 6d1daf0d..4bc25861 100644
--- a/package.xml
+++ b/package.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <package format="3">
   <name>ndcurves</name>
-  <version>1.4.1</version>
+  <version>2.0.0</version>
   <description>
       A template-based Library for creating curves of arbitrary order and dimension
   </description>
diff --git a/python/ndcurves/curves_python.cpp b/python/ndcurves/curves_python.cpp
index f6e52549..c06067c3 100644
--- a/python/ndcurves/curves_python.cpp
+++ b/python/ndcurves/curves_python.cpp
@@ -749,10 +749,10 @@ SE3Curve_t* wrapSE3CurveFromPosAndRotation(const pointX_t& init_pos,
 SE3Curve_t* wrapSE3CurveFromBezier3Translation(bezier3_t& translation_curve,
                                                const matrix3_t& init_rot,
                                                const matrix3_t& end_rot) {
-  boost::shared_ptr<bezier3_t> translation(
-      new bezier3_t(translation_curve.waypoints().begin(),
-                    translation_curve.waypoints().end(),
-                    translation_curve.min(), translation_curve.max()));
+  std::shared_ptr<bezier3_t> translation = std::make_shared<bezier3_t>(
+      translation_curve.waypoints().begin(),
+      translation_curve.waypoints().end(), translation_curve.min(),
+      translation_curve.max());
   return new SE3Curve_t(translation, init_rot, end_rot);
 }
 
@@ -891,8 +891,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
   eigenpy::exposeQuaternion();*/
   /** END eigenpy init**/
   /** Expose base abstracts class for each dimension/type : **/
-  class_<curve_abc_t, boost::noncopyable,
-         boost::shared_ptr<curve_abc_callback>>("curve")
+  class_<curve_abc_t, boost::noncopyable, std::shared_ptr<curve_abc_callback>>(
+      "curve")
       .def("__call__", &curve_abc_t::operator(),
            "Evaluate the curve at the given time.", args("self", "t"))
       .def("derivate", &curve_abc_t::derivate,
@@ -933,7 +933,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<curve_abc_t>());
 
   class_<curve_3_t, boost::noncopyable, bases<curve_abc_t>,
-         boost::shared_ptr<curve_3_callback>>("curve3")
+         std::shared_ptr<curve_3_callback>>("curve3")
       .def("__call__", &curve_3_t::operator(),
            "Evaluate the curve at the given time.", args("self", "t"))
       .def("derivate", &curve_3_t::derivate,
@@ -959,7 +959,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<curve_3_t>());
 
   class_<curve_rotation_t, boost::noncopyable, bases<curve_abc_t>,
-         boost::shared_ptr<curve_rotation_callback>>("curve_rotation")
+         std::shared_ptr<curve_rotation_callback>>("curve_rotation")
       .def("__call__", &curve_rotation_t::operator(),
            "Evaluate the curve at the given time.", args("self", "t"))
       .def("derivate", &curve_rotation_t::derivate,
@@ -985,7 +985,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<curve_rotation_t>());
 
   class_<curve_SE3_t, boost::noncopyable, bases<curve_abc_t>,
-         boost::shared_ptr<curve_SE3_callback>>("curve_SE3")
+         std::shared_ptr<curve_SE3_callback>>("curve_SE3")
       .def("__call__", &se3Return,
            "Evaluate the curve at the given time. Return as an homogeneous "
            "matrix.",
@@ -1039,8 +1039,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
       &bezier3_t::cross;
   bezier3_t (bezier3_t::*cross_pointBez3)(const bezier3_t::point_t&) const =
       &bezier3_t::cross;
-  class_<bezier3_t, bases<curve_3_t>, boost::shared_ptr<bezier3_t>>("bezier3",
-                                                                    init<>())
+  class_<bezier3_t, bases<curve_3_t>, std::shared_ptr<bezier3_t>>("bezier3",
+                                                                  init<>())
       .def("__init__", make_constructor(&wrapBezier3Constructor))
       .def("__init__", make_constructor(&wrapBezier3ConstructorBounds))
       .def("__init__", make_constructor(&wrapBezier3ConstructorConstraints))
@@ -1108,8 +1108,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
   bezier_t (bezier_t::*cross_bez)(const bezier_t&) const = &bezier_t::cross;
   bezier_t (bezier_t::*cross_pointBez)(const bezier_t::point_t&) const =
       &bezier_t::cross;
-  class_<bezier_t, bases<curve_abc_t>, boost::shared_ptr<bezier_t>>("bezier",
-                                                                    init<>())
+  class_<bezier_t, bases<curve_abc_t>, std::shared_ptr<bezier_t>>("bezier",
+                                                                  init<>())
       .def("__init__", make_constructor(&wrapBezierConstructor))
       .def("__init__", make_constructor(&wrapBezierConstructorBounds))
       .def("__init__", make_constructor(&wrapBezierConstructorConstraints))
@@ -1204,8 +1204,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
       const bezier_linear_variable_t::point_t&) const =
       &bezier_linear_variable_t::cross;
   class_<bezier_linear_variable_t, bases<curve_abc_t>,
-         boost::shared_ptr<bezier_linear_variable_t>>("bezier_linear_variable",
-                                                      no_init)
+         std::shared_ptr<bezier_linear_variable_t>>("bezier_linear_variable",
+                                                    no_init)
       .def("__init__", make_constructor(&wrapBezierLinearConstructor))
       .def("__init__", make_constructor(&wrapBezierLinearConstructorBounds))
       .def("min", &bezier_linear_variable_t::min)
@@ -1269,7 +1269,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
   polynomial_t (polynomial_t::*cross_point)(const polynomial_t::point_t&)
       const = &polynomial_t::cross;
 
-  class_<polynomial_t, bases<curve_abc_t>, boost::shared_ptr<polynomial_t>>(
+  class_<polynomial_t, bases<curve_abc_t>, std::shared_ptr<polynomial_t>>(
       "polynomial", init<>())
       .def(
           "__init__",
@@ -1360,7 +1360,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
 
   /** END polynomial function**/
   /** BEGIN piecewise curve function **/
-  class_<piecewise_t, bases<curve_abc_t>, boost::shared_ptr<piecewise_t>>(
+  class_<piecewise_t, bases<curve_abc_t>, std::shared_ptr<piecewise_t>>(
       "piecewise", init<>())
       .def("__init__",
            make_constructor(&wrapPiecewiseCurveConstructor,
@@ -1438,7 +1438,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def(CopyableVisitor<piecewise_t>())
       .def_pickle(curve_pickle_suite<piecewise_t>());
 
-  class_<piecewise3_t, bases<curve_3_t>, boost::shared_ptr<piecewise3_t>>(
+  class_<piecewise3_t, bases<curve_3_t>, std::shared_ptr<piecewise3_t>>(
       "piecewise3", init<>())
       .def("__init__",
            make_constructor(&wrapPiecewise3CurveConstructor,
@@ -1513,7 +1513,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<piecewise3_t>());
 
   class_<piecewise_bezier_t, bases<curve_abc_t>,
-         boost::shared_ptr<piecewise_bezier_t>>("piecewise_bezier", init<>())
+         std::shared_ptr<piecewise_bezier_t>>("piecewise_bezier", init<>())
       .def("__init__",
            make_constructor(&wrapPiecewiseBezierConstructor,
                             default_call_policies(), arg("curve")),
@@ -1537,8 +1537,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<piecewise_bezier_t>());
 
   class_<piecewise_linear_bezier_t, bases<curve_abc_t>,
-         boost::shared_ptr<piecewise_linear_bezier_t>>(
-      "piecewise_bezier_linear", init<>(args("self")))
+         std::shared_ptr<piecewise_linear_bezier_t>>("piecewise_bezier_linear",
+                                                     init<>(args("self")))
       .def("__init__",
            make_constructor(&wrapPiecewiseBezierLinearConstructor,
                             default_call_policies(), arg("curve")),
@@ -1562,8 +1562,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def(CopyableVisitor<piecewise_linear_bezier_t>())
       .def_pickle(curve_pickle_suite<piecewise_linear_bezier_t>());
 
-  class_<piecewise_SE3_t, bases<curve_SE3_t>,
-         boost::shared_ptr<piecewise_SE3_t>>("piecewise_SE3", init<>())
+  class_<piecewise_SE3_t, bases<curve_SE3_t>, std::shared_ptr<piecewise_SE3_t>>(
+      "piecewise_SE3", init<>())
       .def("__init__",
            make_constructor(&wrapPiecewiseSE3Constructor,
                             default_call_policies(), arg("curve")),
@@ -1602,7 +1602,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
 
   /** END piecewise curve function **/
   /** BEGIN exact_cubic curve**/
-  class_<exact_cubic_t, bases<curve_abc_t>, boost::shared_ptr<exact_cubic_t>>(
+  class_<exact_cubic_t, bases<curve_abc_t>, std::shared_ptr<exact_cubic_t>>(
       "exact_cubic", init<>(args("self")))
       .def("__init__",
            make_constructor(&wrapExactCubicConstructor, default_call_policies(),
@@ -1622,8 +1622,8 @@ BOOST_PYTHON_MODULE(ndcurves) {
   /** END exact_cubic curve**/
   /** BEGIN cubic_hermite_spline **/
   class_<cubic_hermite_spline_t, bases<curve_abc_t>,
-         boost::shared_ptr<cubic_hermite_spline_t>>("cubic_hermite_spline",
-                                                    init<>(args("self")))
+         std::shared_ptr<cubic_hermite_spline_t>>("cubic_hermite_spline",
+                                                  init<>(args("self")))
       .def("__init__", make_constructor(&wrapCubicHermiteSplineConstructor,
                                         bp::default_call_policies(),
                                         args("points", "tangents", "times")))
@@ -1661,7 +1661,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
   /** END bernstein polynomial**/
 
   /** BEGIN SO3 Linear**/
-  class_<SO3Linear_t, bases<curve_rotation_t>, boost::shared_ptr<SO3Linear_t>>(
+  class_<SO3Linear_t, bases<curve_rotation_t>, std::shared_ptr<SO3Linear_t>>(
       "SO3Linear", init<>())
       .def("__init__",
            make_constructor(
@@ -1689,7 +1689,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
 
   /** END  SO3 Linear**/
   /** BEGIN SE3 Curve**/
-  class_<SE3Curve_t, bases<curve_SE3_t>, boost::shared_ptr<SE3Curve_t>>(
+  class_<SE3Curve_t, bases<curve_SE3_t>, std::shared_ptr<SE3Curve_t>>(
       "SE3Curve", init<>())
       .def("__init__",
            make_constructor(
@@ -1763,7 +1763,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
 
   /** END SE3 Curve**/
   /** BEGIN constant curve function**/
-  class_<constant_t, bases<curve_abc_t>, boost::shared_ptr<constant_t>>(
+  class_<constant_t, bases<curve_abc_t>, std::shared_ptr<constant_t>>(
       "constant", init<>())
       .def("__init__",
            make_constructor(&wrapConstantConstructorTime,
@@ -1785,7 +1785,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<constant_t>());
   /** END constant function**/
   /** BEGIN constant 3 curve function**/
-  class_<constant3_t, bases<curve_3_t>, boost::shared_ptr<constant3_t>>(
+  class_<constant3_t, bases<curve_3_t>, std::shared_ptr<constant3_t>>(
       "constant3", init<>())
       .def("__init__",
            make_constructor(&wrapConstant3ConstructorTime,
@@ -1807,7 +1807,7 @@ BOOST_PYTHON_MODULE(ndcurves) {
       .def_pickle(curve_pickle_suite<constant3_t>());
   /** END constant 3 function**/
   /** BEGIN sinusoidal curve function**/
-  class_<sinusoidal_t, bases<curve_abc_t>, boost::shared_ptr<sinusoidal_t>>(
+  class_<sinusoidal_t, bases<curve_abc_t>, std::shared_ptr<sinusoidal_t>>(
       "sinusoidal", init<>())
       .def("__init__",
            make_constructor(&wrapSinusoidalConstructor, default_call_policies(),
diff --git a/python/test/sandbox/test.ipynb b/python/test/sandbox/test.ipynb
index 9d9ff84a..e9dfacb2 100644
--- a/python/test/sandbox/test.ipynb
+++ b/python/test/sandbox/test.ipynb
@@ -48,24 +48,19 @@
    ],
    "source": [
     "# importing classical numpy objects\n",
-    "from numpy import zeros, array, identity, dot\n",
-    "from numpy.linalg import norm\n",
-    "import numpy as np\n",
-    "\n",
-    "np.set_printoptions(formatter={\"float\": lambda x: \"{0:0.1f}\".format(x)})\n",
-    "\n",
     "# use array representation for binding eigen objects to python\n",
-    "import eigenpy\n",
-    "\n",
-    "\n",
     "# importing the bezier curve class\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from numpy import array, dot, identity, zeros\n",
+    "from numpy.linalg import norm\n",
+    "\n",
     "from ndcurves import bezier\n",
     "\n",
     "# importing tools to plot bezier curves\n",
     "from ndcurves.plot import plotBezier\n",
-    "from mpl_toolkits.mplot3d import Axes3D\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
+    "\n",
+    "np.set_printoptions(formatter={\"float\": lambda x: f\"{x:0.1f}\"})\n",
     "\n",
     "# We describe a degree 3 curve as a Bezier curve with 4 control points\n",
     "waypoints = array(\n",
diff --git a/tests/Main.cpp b/tests/Main.cpp
index 3004309f..18812c31 100644
--- a/tests/Main.cpp
+++ b/tests/Main.cpp
@@ -1,7 +1,7 @@
-#include <boost/smart_ptr/shared_ptr.hpp>
 #include <cmath>
 #include <ctime>
 #include <iostream>
+#include <memory>
 #include <string>
 
 #include "load_problem.h"
@@ -90,8 +90,8 @@ void CompareCurves(const curve1& c1, const curve2& c2,
     std::cout
         << errMsg
         << "CompareCurves, ERROR, time min and max of curves do not match ["
-        << T_min << "," << T_max << "] " << " and [" << c2.min() << ","
-        << c2.max() << "] " << std::endl;
+        << T_min << "," << T_max << "] "
+        << " and [" << c2.min() << "," << c2.max() << "] " << std::endl;
     error = true;
   } else {
     // derivative in T_min and T_max
@@ -1311,12 +1311,12 @@ void piecewiseCurveTest(bool& error) {
     vec2.push_back(b);  // x=2, y=1, z=1
     vec3.push_back(c);  // x=3, y=1, z=1
     // Create three polynomials of constant value in the interval of definition
-    boost::shared_ptr<polynomial_t> pol1_ptr(
-        new polynomial_t(vec1.begin(), vec1.end(), 0, 1));
-    boost::shared_ptr<polynomial_t> pol2_ptr(
-        new polynomial_t(vec2.begin(), vec2.end(), 1, 2));
-    boost::shared_ptr<polynomial_t> pol3_ptr(
-        new polynomial_t(vec3.begin(), vec3.end(), 2, 3));
+    std::shared_ptr<polynomial_t> pol1_ptr =
+        std::make_shared<polynomial_t>(vec1.begin(), vec1.end(), 0, 1);
+    std::shared_ptr<polynomial_t> pol2_ptr =
+        std::make_shared<polynomial_t>(vec2.begin(), vec2.end(), 1, 2);
+    std::shared_ptr<polynomial_t> pol3_ptr =
+        std::make_shared<polynomial_t>(vec3.begin(), vec3.end(), 2, 3);
     // 1 polynomial in curve
     piecewise_t pc(pol1_ptr);
     res = pc(0.5);
@@ -1355,10 +1355,10 @@ void piecewiseCurveTest(bool& error) {
     params1.push_back(c0);
     params1.push_back(b0);
     params1.push_back(a0);
-    boost::shared_ptr<bezier_t> bc0_ptr(
-        new bezier_t(params0.begin(), params0.end(), 0., 1.));
-    boost::shared_ptr<bezier_t> bc1_ptr(
-        new bezier_t(params1.begin(), params1.end(), 1., 2.));
+    std::shared_ptr<bezier_t> bc0_ptr =
+        std::make_shared<bezier_t>(params0.begin(), params0.end(), 0., 1.);
+    std::shared_ptr<bezier_t> bc1_ptr =
+        std::make_shared<bezier_t>(params1.begin(), params1.end(), 1., 2.);
     piecewise_t pc_C0(bc0_ptr);
     pc_C0.add_curve_ptr(bc1_ptr);
     // Check value in t=0.5 and t=1.5
@@ -1388,14 +1388,14 @@ void piecewiseCurveTest(bool& error) {
     time_control_points0.push_back(1.);  // hermite 0 between [0,1]
     time_control_points1.push_back(1.);
     time_control_points1.push_back(3.);  // hermite 1 between [1,3]
-    boost::shared_ptr<cubic_hermite_spline_t> chs0_ptr(
-        new cubic_hermite_spline_t(control_points_0.begin(),
-                                   control_points_0.end(),
-                                   time_control_points0));
-    boost::shared_ptr<cubic_hermite_spline_t> chs1_ptr(
-        new cubic_hermite_spline_t(control_points_1.begin(),
-                                   control_points_1.end(),
-                                   time_control_points1));
+    std::shared_ptr<cubic_hermite_spline_t> chs0_ptr =
+        std::make_shared<cubic_hermite_spline_t>(control_points_0.begin(),
+                                                 control_points_0.end(),
+                                                 time_control_points0);
+    std::shared_ptr<cubic_hermite_spline_t> chs1_ptr =
+        std::make_shared<cubic_hermite_spline_t>(control_points_1.begin(),
+                                                 control_points_1.end(),
+                                                 time_control_points1);
     piecewise_t pc_C1(chs0_ptr);
     pc_C1.add_curve_ptr(chs1_ptr);
     // Create piecewise curve C2
@@ -1408,10 +1408,10 @@ void piecewiseCurveTest(bool& error) {
     // in [1,2]
     vecb.push_back(b1);
     vecb.push_back(b1);  // x=(t-1)+1, y=(t-1)+1, z=(t-1)+1
-    boost::shared_ptr<polynomial_t> pola_ptr(
-        new polynomial_t(veca.begin(), veca.end(), 0, 1));
-    boost::shared_ptr<polynomial_t> polb_ptr(
-        new polynomial_t(vecb.begin(), vecb.end(), 1, 2));
+    std::shared_ptr<polynomial_t> pola_ptr =
+        std::make_shared<polynomial_t>(veca.begin(), veca.end(), 0, 1);
+    std::shared_ptr<polynomial_t> polb_ptr =
+        std::make_shared<polynomial_t>(vecb.begin(), vecb.end(), 1, 2);
     piecewise_t pc_C2(pola_ptr);
     pc_C2.add_curve_ptr(polb_ptr);
     // check C0 continuity
@@ -2323,8 +2323,8 @@ void se3CurveTest(bool& error) {
     params.push_back(b);
     params.push_back(c);
     params.push_back(d);
-    boost::shared_ptr<bezier3_t> translation_bezier(
-        new bezier3_t(params.begin(), params.end(), min, max));
+    std::shared_ptr<bezier3_t> translation_bezier =
+        std::make_shared<bezier3_t>(params.begin(), params.end(), min, max);
     cBezier = SE3Curve_t(translation_bezier, q0.toRotationMatrix(),
                          q1.toRotationMatrix());
     p0 = (*translation_bezier)(min);
@@ -2522,8 +2522,8 @@ void Se3serializationTest(bool& error) {
     params.push_back(b);
     params.push_back(c);
     params.push_back(d);
-    boost::shared_ptr<bezier3_t> translation_bezier(
-        new bezier3_t(params.begin(), params.end(), min, max));
+    std::shared_ptr<bezier3_t> translation_bezier =
+        std::make_shared<bezier3_t>(params.begin(), params.end(), min, max);
     cBezier = SE3Curve_t(translation_bezier, q0, q1);
   }
 
@@ -3172,10 +3172,12 @@ void testOperatorEqual(bool& error) {
 
   // SE3
   polynomial3_t pol3_0 = polynomial_from_curve<polynomial3_t>(bc3_0);
-  boost::shared_ptr<bezier3_t> translation_bezier(new bezier3_t(bc3_0));
-  boost::shared_ptr<bezier3_t> translation_bezier2(new bezier3_t(bc3_0));
-  boost::shared_ptr<polynomial3_t> translation_polynomial(
-      new polynomial3_t(pol3_0));
+  std::shared_ptr<bezier3_t> translation_bezier =
+      std::make_shared<bezier3_t>(bc3_0);
+  std::shared_ptr<bezier3_t> translation_bezier2 =
+      std::make_shared<bezier3_t>(bc3_0);
+  std::shared_ptr<polynomial3_t> translation_polynomial =
+      std::make_shared<polynomial3_t>(pol3_0);
   SE3Curve_t se3_bezier1 = SE3Curve_t(translation_bezier, q0.toRotationMatrix(),
                                       q1.toRotationMatrix());
   SE3Curve_t se3_bezier12 = SE3Curve_t(
@@ -3185,8 +3187,8 @@ void testOperatorEqual(bool& error) {
   SE3Curve_t se3_bezier2(se3_bezier1);
   SE3Curve_t se3_bezier3 = SE3Curve_t(translation_bezier, q0.toRotationMatrix(),
                                       q2.toRotationMatrix());
-  boost::shared_ptr<polynomial3_t> translation_polynomial2(
-      new polynomial3_t(pol3_2));
+  std::shared_ptr<polynomial3_t> translation_polynomial2 =
+      std::make_shared<polynomial3_t>(pol3_2);
   SE3Curve_t se3_pol2 = SE3Curve_t(
       translation_polynomial2, q0.toRotationMatrix(), q1.toRotationMatrix());
   // std::cout<<"Should call se3 method : "<<std::endl;
@@ -3240,10 +3242,10 @@ void testOperatorEqual(bool& error) {
   params1.push_back(c0);
   params1.push_back(b0);
   params1.push_back(a0);
-  boost::shared_ptr<bezier_t> bc0_ptr(
-      new bezier_t(params0.begin(), params0.end(), 0., 1.));
-  boost::shared_ptr<bezier_t> bc1_ptr(
-      new bezier_t(params1.begin(), params1.end(), 1., 2.));
+  std::shared_ptr<bezier_t> bc0_ptr =
+      std::make_shared<bezier_t>(params0.begin(), params0.end(), 0., 1.);
+  std::shared_ptr<bezier_t> bc1_ptr =
+      std::make_shared<bezier_t>(params1.begin(), params1.end(), 1., 2.);
   piecewise_t pc_C0(bc0_ptr);
   pc_C0.add_curve_ptr(bc1_ptr);
   piecewise_t pc_C1(bc0_ptr);
@@ -3251,8 +3253,8 @@ void testOperatorEqual(bool& error) {
   piecewise_t pc_C2(pc_C0);
   piecewise_t pc_C3(bc0_ptr);
   piecewise_t pc_C4(bc0_ptr);
-  boost::shared_ptr<bezier_t> bc2_ptr(
-      new bezier_t(params0.begin(), params0.end(), 1., 2.));
+  std::shared_ptr<bezier_t> bc2_ptr =
+      std::make_shared<bezier_t>(params0.begin(), params0.end(), 1., 2.);
   pc_C4.add_curve_ptr(bc2_ptr);
   // std::cout<<"Should call piecewise method -> bezier , bezier: "<<std::endl;
   if (pc_C0 != pc_C1) {
@@ -3297,16 +3299,17 @@ void testOperatorEqual(bool& error) {
       translation_polynomial->derivate(translation_polynomial->max(), 1));
   point3_t p_end_se3(1, -2, 6);
   point3_t dp_end_se3(3.5, 2.5, -9);
-  boost::shared_ptr<polynomial3_t> translation_pol3(new polynomial3_t(
-      p_init_se3, dp_init_se3, p_end_se3, dp_end_se3,
-      translation_polynomial->max(), translation_polynomial->max() + 2.5));
+  std::shared_ptr<polynomial3_t> translation_pol3 =
+      std::make_shared<polynomial3_t>(p_init_se3, dp_init_se3, p_end_se3,
+                                      dp_end_se3, translation_polynomial->max(),
+                                      translation_polynomial->max() + 2.5);
   curve_SE3_ptr_t se3_pol_3(new SE3Curve_t(
       translation_pol3, q1.toRotationMatrix(), q2.toRotationMatrix()));
   pc_se3_1.add_curve_ptr(se3_pol_3);
   piecewise_SE3_t pc_se3_2(pc_se3_1);
-  piecewise_SE3_t pc_se3_3(boost::make_shared<SE3Curve_t>(se3_pol1));
+  piecewise_SE3_t pc_se3_3(std::make_shared<SE3Curve_t>(se3_pol1));
   pc_se3_3.add_curve_ptr(se3_pol_3);
-  piecewise_SE3_t pc_se3_4(boost::make_shared<SE3Curve_t>(se3_pol2));
+  piecewise_SE3_t pc_se3_4(std::make_shared<SE3Curve_t>(se3_pol2));
   pc_se3_4.add_curve_ptr(se3_pol_3);
   // std::cout<<"Should call piecewise method -> SE3 , SE3: "<<std::endl;
   if (pc_se3_1 != pc_se3_2) {