diff --git a/beluga/include/beluga/localization.hpp b/beluga/include/beluga/localization.hpp
index ae6ac2000..277b21b87 100644
--- a/beluga/include/beluga/localization.hpp
+++ b/beluga/include/beluga/localization.hpp
@@ -44,6 +44,19 @@ namespace beluga {
  * - \ref localization.hpp
  */
 
+/// Composes multiple interfaces into a single interface type.
+/**
+ * \tparam Interfaces Interfaces to combine.
+ */
+template <class... Interfaces>
+struct compose_interfaces : public Interfaces... {
+  /// Virtual destructor.
+  /**
+   * Makes it so at least one of the interfaces provides a virtual destructor.
+   */
+  ~compose_interfaces() override = default;
+};
+
 /// A null mixin interface. Meant to be the default value for an optional customization point.
 class NullMixinInterface {
  public:
@@ -70,7 +83,7 @@ class NullMixin : public Mixin {
  * \tparam CustomExtensionMixinInterface An optional mixin interface for the user to customize the filter.
  */
 template <class Map, class CustomExtensionMixinInterface = NullMixinInterface>
-using LaserLocalizationInterface2d = beluga::mixin::compose_interfaces<
+using LaserLocalizationInterface2d = beluga::compose_interfaces<
     BaseParticleFilterInterface,
     StorageInterface<Sophus::SE2d, beluga::Weight>,
     EstimationInterface2d,
@@ -78,22 +91,52 @@ using LaserLocalizationInterface2d = beluga::mixin::compose_interfaces<
     LaserSensorModelInterface2d<Map>,
     CustomExtensionMixinInterface>;
 
+/// \cond
+
+/// Wrapper to convert a motion model class into a mixin.
+template <typename Mixin, typename Model>
+struct MotionMixin : public Mixin, public Model {
+  using update_type = typename Model::update_type;
+
+  template <typename... Args>
+  constexpr explicit MotionMixin(Model model, Args&&... args)
+      : Model(std::move(model)), Mixin(static_cast<decltype(args)>(args)...) {}
+
+  void update_motion(const update_type& pose) { Model::update_motion(pose); }
+};
+
+/// Wrapper to convert a sensor model class into a mixin.
+template <typename Mixin, typename Model>
+struct SensorMixin : public Mixin, public Model {
+  using measurement_type = typename Model::measurement_type;
+  using map_type = typename Model::map_type;
+
+  template <typename... Args>
+  constexpr explicit SensorMixin(Model model, Args&&... args)
+      : Model(std::move(model)), Mixin(static_cast<decltype(args)>(args)...) {}
+
+  void update_sensor(measurement_type&& measurement) { Model::update_sensor(std::move(measurement)); }
+  void update_map(map_type&& map) { Model::update_map(std::move(map)); }
+};
+
+/// \endcond
+
 /// An implementation of Monte Carlo Localization.
 /**
  * An instance of this class template implements beluga::LaserLocalizationInterface2d
  * and \ref LocalizationPage.
  *
- * \tparam MotionDescriptor A descriptor of a mixin that implements \ref MotionModelPage.
- * \tparam SensorDescriptor A descriptor of a mixin that implements \ref SensorModelPage.
+ * \tparam MotionModel A class that implements \ref MotionModelPage.
+ * \tparam SensorModel A class that implements \ref SensorModelPage.
  * \tparam Map Environment representation type consistent with the sensor descriptor.
- * \tparam CustomExtensionMixinInterface An optional mixin interface for the user to customize the filter.
+ * \tparam Interface An optional mixin interface for the user to customize the filter.
  * \tparam CustomExtensionMixin An optional mixin type for the user to customize the filter.
  */
 template <
-    class MotionDescriptor,
-    class SensorDescriptor,
+    class MotionModel,
+    class SensorModel,
     class Map,
-    class CustomExtensionMixinInterface = NullMixinInterface,
+    class Interface = NullMixinInterface,
     template <class> class CustomExtensionMixin = NullMixin>
 using MonteCarloLocalization2d = ciabatta::mixin<
     BootstrapParticleFilter,
@@ -102,27 +145,27 @@ using MonteCarloLocalization2d = ciabatta::mixin<
     RandomStateGenerator,
     NaiveSampler,
     FixedLimiter,
-    MotionDescriptor::template mixin,
-    SensorDescriptor::template mixin,
+    ciabatta::curry<MotionMixin, MotionModel>::template mixin,
+    ciabatta::curry<SensorMixin, SensorModel>::template mixin,
     CustomExtensionMixin,
-    ciabatta::provides<LaserLocalizationInterface2d<Map, CustomExtensionMixinInterface>>::template mixin>;
+    ciabatta::provides<Interface>::template mixin>;
 
 /// An implementation of Adaptive Monte Carlo Localization.
 /**
  * An instance of this class template implements beluga::LaserLocalizationInterface2d
  * and \ref LocalizationPage.
  *
- * \tparam MotionDescriptor A descriptor of a mixin that implements \ref MotionModelPage.
- * \tparam SensorDescriptor A descriptor of a mixin that implements \ref SensorModelPage.
+ * \tparam MotionModel A class that implements \ref MotionModelPage.
+ * \tparam SensorModel A class that implements \ref SensorModelPage.
  * \tparam Map Environment representation type consistent with the sensor descriptor.
- * \tparam CustomExtensionMixinInterface An optional mixin interface for the user to customize the filter.
+ * \tparam Interface An optional mixin interface for the user to customize the filter.
  * \tparam CustomExtensionMixin An optional mixin type for the user to customize the filter.
  */
 template <
-    class MotionDescriptor,
-    class SensorDescriptor,
+    class MotionModel,
+    class SensorModel,
     class Map,
-    class CustomExtensionMixinInterface = NullMixinInterface,
+    class Interface = NullMixinInterface,
     template <class> class CustomExtensionMixin = NullMixin>
 using AdaptiveMonteCarloLocalization2d = ciabatta::mixin<
     BootstrapParticleFilter,
@@ -131,10 +174,10 @@ using AdaptiveMonteCarloLocalization2d = ciabatta::mixin<
     RandomStateGenerator,
     AdaptiveSampler,
     ciabatta::curry<KldLimiter, Sophus::SE2d>::mixin,
-    MotionDescriptor::template mixin,
-    SensorDescriptor::template mixin,
+    ciabatta::curry<MotionMixin, MotionModel>::template mixin,
+    ciabatta::curry<SensorMixin, SensorModel>::template mixin,
     CustomExtensionMixin,
-    ciabatta::provides<LaserLocalizationInterface2d<Map, CustomExtensionMixinInterface>>::template mixin>;
+    ciabatta::provides<Interface>::template mixin>;
 
 }  // namespace beluga
 
diff --git a/beluga/include/beluga/mixin.hpp b/beluga/include/beluga/mixin.hpp
index 8cf2d144e..b4f6fc544 100644
--- a/beluga/include/beluga/mixin.hpp
+++ b/beluga/include/beluga/mixin.hpp
@@ -15,13 +15,9 @@
 #ifndef BELUGA_MIXIN_HPP
 #define BELUGA_MIXIN_HPP
 
-#include <memory>
-
-#include <beluga/mixin/descriptor.hpp>
 #include <beluga/mixin/particle_filter.hpp>
 #include <beluga/mixin/sampling.hpp>
 #include <beluga/mixin/storage.hpp>
-#include <beluga/mixin/utility.hpp>
 #include <ciabatta/ciabatta.hpp>
 
 /**
@@ -29,76 +25,4 @@
  * \brief Implementation of mixin utilities and extensions.
  */
 
-namespace beluga::mixin {
-
-/// Composes multiple interfaces into a single interface type.
-/**
- * \tparam Interfaces Interfaces to combine.
- */
-template <class... Interfaces>
-struct compose_interfaces : public Interfaces... {
-  /// Virtual destructor.
-  /**
-   * Makes it so at least one of the interfaces provides a virtual destructor.
-   */
-  ~compose_interfaces() override = default;
-};
-
-/// Helper method to get descriptor parameters or forward the value.
-/**
- * \tparam T The type of the input value.
- * \param value A value to get the params from, or to forward.
- * \return The params with the same value category of the input value or
- * the input value forwarded.
- */
-template <class T>
-constexpr auto&& params_or_forward(T&& value) noexcept {
-  if constexpr (is_descriptor_v<T> && has_params_v<T>) {
-    return forward_like<T>(value.params);
-  } else {
-    return std::forward<T>(value);
-  }
-}
-
-/// Constructs a mixin and wraps it into a `std::unique_ptr` to a given interface.
-/**
- * This method can be used to create different mixin alternatives based on
- * the input arguments. The input arguments can be parameters of the mixin constructor
- * or descriptor variants holding parameters of the mixin constructor.
- *
- * This function will use the descriptor information to instantiate the correct
- * mixin type and construct it with the given parameters.
- *
- * Descriptors can also contain no parameters, in which case the type information
- * will be used to deduce the mixin type and there is no need to forward parameter
- * values to the constructor.
- *
- * All the possible mixin alternatives from the input variants must implement `Interface`,
- * and the `Interface` type must be specified since this function must return the
- * same type for all possible combinations of variants.
- *
- * Examples:
- * \snippet test/beluga/test_mixin.cpp Using make_mixin
- *
- * \tparam Interface The interface type used to create the std::unique_ptr.
- * \tparam Base A base mixin template taking descriptors.
- * \tparam Args The input argument or descriptor types from which to instantiate the mixin.
- * \param args The input arguments or descriptor instances from which to construct the mixin.
- * \return A `std::unique_ptr` of an instance of type `Interface`.
- */
-template <class Interface, template <class...> class Base, class... Args>
-auto make_mixin(Args&&... args) {
-  return visit_everything(
-      [](auto&&... args) {
-        using InnerArgs = list<decltype(args)...>;  // avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86859
-        using Concrete = mixin_from_descriptors_t<Base, filter<is_descriptor, InnerArgs>>;
-        return std::apply(
-            [](auto&&... args) -> std::unique_ptr<Interface> { return std::make_unique<Concrete>(args...); },
-            make_tuple_with<is_not_descriptor>(params_or_forward(args)...));
-      },
-      args...);
-}
-
-}  // namespace beluga::mixin
-
 #endif
diff --git a/beluga/include/beluga/mixin/descriptor.hpp b/beluga/include/beluga/mixin/descriptor.hpp
deleted file mode 100644
index b88410160..000000000
--- a/beluga/include/beluga/mixin/descriptor.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2023 Ekumen, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef BELUGA_MIXIN_DESCRIPTOR_HPP
-#define BELUGA_MIXIN_DESCRIPTOR_HPP
-
-#include <type_traits>
-
-#include <beluga/mixin/utility.hpp>
-
-/**
- * \file
- * \brief Implementation of descriptors and their traits.
- */
-
-namespace beluga::mixin {
-
-/// Primary template for a mixin descriptor.
-/**
- * \tparam Mixin A mixin template class.
- * \tparam Params A variadic list of parameter types.
- */
-template <template <class> class Mixin, class... Params>
-struct descriptor;
-
-/// Partial template specialization for mixin descriptor with no parameters.
-/**
- * \tparam Mixin A mixin template class.
- */
-template <template <class> class Mixin>
-struct descriptor<Mixin> {
-  /// The mixin template type.
-  template <class Base>
-  using mixin = Mixin<Base>;
-};
-
-/// Partial template specialization for mixin descriptor with a single parameter.
-/**
- * \tparam Mixin A mixin template class.
- * \tparam Param The parameter type.
- */
-template <template <class> class Mixin, class Param>
-struct descriptor<Mixin, Param> {
-  /// The mixin template type.
-  template <class Base>
-  using mixin = Mixin<Base>;
-
-  /// The parameter object.
-  Param params;
-};
-
-/// \cond detail
-
-namespace detail {
-
-template <class T, typename Enable = void>
-struct has_params_impl : public std::false_type {};
-
-template <class T>
-struct has_params_impl<T, std::void_t<decltype(std::declval<T&>().params)>> : public std::true_type {};
-
-template <typename T>
-struct is_descriptor_impl : public std::false_type {};
-
-template <template <class> class Mixin>
-struct is_descriptor_impl<descriptor<Mixin>> : public std::true_type {};
-
-template <template <class> class Mixin, class Param>
-struct is_descriptor_impl<descriptor<Mixin, Param>> : public std::true_type {};
-
-}  // namespace detail
-
-/// \endcond
-
-/// Trait to detect that a given type has a params member.
-/**
- * If `T` (after decay) has a `params` variable member,
- * provides a member constant value equal to `true`. For any other type, value is `false`.
- *
- * \tparam T A type to check.
- */
-template <typename T>
-struct has_params {
-  /// Member constant value.
-  static constexpr bool value = detail::has_params_impl<std::decay_t<T>>::value;  // NOLINT
-};
-
-/// Helper variable template to detect that a given type has a params member.
-template <typename T>
-inline constexpr bool has_params_v = has_params<T>::value;  // NOLINT
-
-/// Type trait to detect that a given type is a descriptor.
-/**
- * If `T` (after decay) is an instantiation of \ref beluga::mixin::descriptor,
- * provides a member constant value equal to `true`. For any other type, value is `false`.
- *
- * \tparam T A type to check.
- */
-template <typename T>
-struct is_descriptor {
-  /// Member constant value.
-  static constexpr bool value = detail::is_descriptor_impl<std::decay_t<T>>::value;  // NOLINT
-};
-
-/// Helper type alias to detect that a given type is not a descriptor.
-template <typename T>
-using is_not_descriptor = std::negation<is_descriptor<T>>;
-
-/// Helper variable template to detect that a given type is a descriptor.
-template <typename T>
-inline constexpr bool is_descriptor_v = is_descriptor<T>::value;  // NOLINT
-
-/// A metafunction that returns a mixin type from descriptors.
-/**
- * \tparam Base A base mixin template taking descriptors.
- * \tparam Descriptors The descriptors from which to instantiate the mixin.
- */
-template <template <class...> class Base, class... Descriptors>
-struct mixin_from_descriptors {
-  /// The type of the mixin.
-  using type = Base<std::decay_t<Descriptors>...>;
-
-  static_assert((is_descriptor_v<Descriptors> && ...), "Invalid mixin descriptors");
-};
-
-/// A template specialization that returns a mixin type from a list of descriptors.
-/**
- * \tparam Base A base mixin template taking descriptors.
- * \tparam List Any variadic template type.
- * \tparam Descriptors The descriptors from which to instantiate the mixin.
- */
-template <template <class...> class Base, template <class...> class List, class... Descriptors>
-struct mixin_from_descriptors<Base, List<Descriptors...>> {
-  /// The type of the mixin.
-  using type = Base<std::decay_t<Descriptors>...>;
-
-  static_assert((is_descriptor_v<Descriptors> && ...), "Invalid mixin descriptors");
-};
-
-/// Helper type alias that returns a mixin type from descriptors.
-template <template <class...> class Base, class... Descriptors>
-using mixin_from_descriptors_t = typename mixin_from_descriptors<Base, Descriptors...>::type;
-
-}  // namespace beluga::mixin
-
-#endif
diff --git a/beluga/include/beluga/mixin/utility.hpp b/beluga/include/beluga/mixin/utility.hpp
deleted file mode 100644
index 58823dfd0..000000000
--- a/beluga/include/beluga/mixin/utility.hpp
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2023 Ekumen, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef BELUGA_MIXIN_UTILITY_HPP
-#define BELUGA_MIXIN_UTILITY_HPP
-
-#include <functional>
-#include <type_traits>
-#include <variant>
-
-#include <beluga/utility/forward_like.hpp>
-
-/**
- * \file
- * \brief Implementation of extensions to the standard utility library.
- */
-
-namespace beluga::mixin {
-
-/// \cond lists
-
-template <typename...>
-struct list;
-
-template <typename... Lists>
-struct concat;
-
-template <>
-struct concat<> {
-  using type = list<>;
-};
-
-template <typename... Ts>
-struct concat<list<Ts...>> {
-  using type = list<Ts...>;
-};
-
-template <typename... Ts, typename... Us>
-struct concat<list<Ts...>, list<Us...>> {
-  using type = list<Ts..., Us...>;
-};
-
-template <typename... Ts, typename... Us, typename... Rest>
-struct concat<list<Ts...>, list<Us...>, Rest...> {
-  using type = typename concat<list<Ts..., Us...>, Rest...>::type;
-};
-
-/// \endcond lists
-
-/// \cond detail
-
-namespace detail {
-
-template <template <typename> class Pred, typename List>
-struct filter_impl;
-
-template <template <typename> class Pred, typename... Ts>
-struct filter_impl<Pred, list<Ts...>> {
-  template <template <typename> class P, typename T>
-  using helper = std::conditional_t<P<T>::value, list<T>, list<>>;
-
-  using type = typename concat<helper<Pred, Ts>...>::type;
-};
-
-template <typename T>
-struct is_variant_impl : std::false_type {};
-
-template <typename... Args>
-struct is_variant_impl<std::variant<Args...>> : std::true_type {};
-
-template <typename T>
-struct is_reference_wrapper_impl : std::false_type {};
-
-template <typename T>
-struct is_reference_wrapper_impl<std::reference_wrapper<T>> : std::true_type {};
-
-}  // namespace detail
-
-/// \endcond
-
-/// \cond filter
-
-template <template <typename> class Pred, typename List>
-using filter = typename detail::filter_impl<Pred, List>::type;
-
-/// \endcond filter
-
-/// Type trait to detect that a given type is a variant.
-/**
- * If `T` (after decay) is an instantiation of
- * [std::variant](https://en.cppreference.com/w/cpp/utility/variant),
- * provides a member constant value equal to `true`. For any other type, value is `false`.
- *
- * \tparam T A type to check.
- */
-template <typename T>
-struct is_variant {
-  /// Member constant value.
-  static constexpr bool value = detail::is_variant_impl<std::decay_t<T>>::value;  // NOLINT
-};
-
-/// Helper variable template to detect that a given type is a variant.
-template <typename T>
-inline constexpr bool is_variant_v = is_variant<T>::value;  // NOLINT
-
-/// Type trait to detect that a given type is a reference wrapper.
-/**
- * If `T` (after decay) is an instantiation of
- * [std::reference_wrapper](https://en.cppreference.com/w/cpp/utility/functional/reference_wrapper),
- * provides a member constant value equal to `true`. For any other type, value is `false`.
- *
- * \tparam T A type to check.
- */
-template <typename T>
-struct is_reference_wrapper {
-  /// Member constant value.
-  static constexpr bool value = detail::is_reference_wrapper_impl<std::decay_t<T>>::value;  // NOLINT
-};
-
-/// Helper variable template to detect that a given type is a reference wrapper.
-template <typename T>
-inline constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;  // NOLINT
-
-/// Helper function to unwrap a reference_wrapper or forward the given value.
-/**
- * \tparam T The type of the input value.
- * \param value A reference_wrapper value to unwrap or a value to forward.
- * \return The unwrapped reference or the forwarded value.
- */
-template <class T>
-constexpr decltype(auto) maybe_unwrap(T&& value) noexcept {
-  if constexpr (is_reference_wrapper_v<T>) {
-    return value.get();
-  } else {
-    return std::forward<T>(value);
-  }
-}
-
-/// Helper function to create a variant or forward if the value is already a variant.
-/**
- * \tparam T The type of the input value.
- * \param value A value to forward or to create a variant instance.
- * \return A variant value whose type is a `reference_wrapper` to the input value
- * or an existing variant value forwarded.
- */
-template <class T>
-constexpr decltype(auto) maybe_variant(T&& value) noexcept {
-  if constexpr (!is_variant_v<T>) {
-    return std::variant<std::reference_wrapper<std::decay_t<T>>>(std::ref(value));
-  } else {
-    return std::forward<T>(value);
-  }
-}
-
-/// Applies the visitor to a combination of types from variants, also taking non-variant values.
-/**
- * See also https://en.cppreference.com/w/cpp/utility/variant/visit.
- *
- * \tparam Visitor Callable type that can be called with any combination of types from variants.
- * \tparam Args Input argument types for the visitor, can be variant and non-variant types.
- * \param vis A callable that accepts every possible alternative from every variant.
- * \param args List of arguments to pass to the visitor.
- */
-template <class Visitor, class... Args>
-constexpr decltype(auto) visit_everything(Visitor&& vis, Args&&... args) {
-  return std::visit(
-      [&](auto&&... args) -> decltype(auto) { return std::forward<Visitor>(vis)(maybe_unwrap(args)...); },
-      maybe_variant(std::forward<Args>(args))...);
-}
-
-/// Creates a tuple object omiting the element types that don't match the given predicate.
-/**
- * See also https://en.cppreference.com/w/cpp/utility/tuple/make_tuple.
- *
- * \tparam Pred A template type trait to be used to filter types from the tuple.
- * \tparam Values The types of the input arguments.
- * \param values Zero or more arguments to construct the tuple from.
- */
-template <template <typename> class Pred, class... Values>
-constexpr auto make_tuple_with(Values&&... values) {
-  constexpr auto helper = [](auto&& value) {  // NOLINT
-    if constexpr (Pred<decltype(value)>::value) {
-      return std::forward_as_tuple(std::forward<decltype(value)>(value));
-    } else {
-      return std::tuple<>{};
-    }
-  };
-  return std::tuple_cat(helper(std::forward<decltype(values)>(values))...);
-}
-
-}  // namespace beluga::mixin
-
-#endif
diff --git a/beluga/include/beluga/motion/differential_drive_model.hpp b/beluga/include/beluga/motion/differential_drive_model.hpp
index 3731cf719..6a17749e0 100644
--- a/beluga/include/beluga/motion/differential_drive_model.hpp
+++ b/beluga/include/beluga/motion/differential_drive_model.hpp
@@ -67,11 +67,8 @@ struct DifferentialDriveModelParam {
  * This class implements OdometryMotionModelInterface2d and satisfies \ref MotionModelPage.
  *
  * See Probabilistic Robotics \cite thrun2005probabilistic Chapter 5.4.2.
- *
- * \tparam Mixin The mixed-in type with no particular requirements.
  */
-template <class Mixin>
-class DifferentialDriveModel : public Mixin {
+class DifferentialDriveModel {
  public:
   /// Update type of the motion model, same as the state_type in the odometry model.
   using update_type = Sophus::SE2d;
@@ -83,14 +80,11 @@ class DifferentialDriveModel : public Mixin {
 
   /// Constructs a DifferentialDriveModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance.
    *  See beluga::DifferentialDriveModelParam for details.
-   * \param ...args Arguments that are not used by this part of the mixin, but by others.
    */
   template <class... Args>
-  explicit DifferentialDriveModel(const param_type& params, Args&&... args)
-      : Mixin(std::forward<Args>(args)...), params_{params} {}
+  explicit DifferentialDriveModel(const param_type& params) : params_{params} {}
 
   /// Applies the last motion update to the given particle state.
   /**
@@ -110,7 +104,7 @@ class DifferentialDriveModel : public Mixin {
   }
 
   /// \copydoc OdometryMotionModelInterface2d::update_motion(const Sophus::SE2d&)
-  void update_motion(const update_type& pose) final {
+  void update_motion(const update_type& pose) {
     if (last_pose_) {
       const auto translation = pose.translation() - last_pose_.value().translation();
       const double distance = translation.norm();
diff --git a/beluga/include/beluga/motion/omnidirectional_drive_model.hpp b/beluga/include/beluga/motion/omnidirectional_drive_model.hpp
index f331881e4..2d30041c7 100644
--- a/beluga/include/beluga/motion/omnidirectional_drive_model.hpp
+++ b/beluga/include/beluga/motion/omnidirectional_drive_model.hpp
@@ -70,11 +70,8 @@ struct OmnidirectionalDriveModelParam {
 /// Sampled odometry model for an omnidirectional drive.
 /**
  * This class implements the OdometryMotionModelInterface2d and satisfies \ref MotionModelPage.
- *
- * \tparam Mixin The mixed-in type with no particular requirements.
  */
-template <class Mixin>
-class OmnidirectionalDriveModel : public Mixin {
+class OmnidirectionalDriveModel {
  public:
   /// Update type of the motion model, same as the state_type in the odometry model.
   using update_type = Sophus::SE2d;
@@ -86,14 +83,10 @@ class OmnidirectionalDriveModel : public Mixin {
 
   /// Constructs an OmnidirectionalDriveModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance.
    *  See beluga::OmnidirectionalDriveModelParam for details.
-   * \param ...args Arguments that are not used by this part of the mixin, but by others.
    */
-  template <class... Args>
-  explicit OmnidirectionalDriveModel(const param_type& params, Args&&... args)
-      : Mixin(std::forward<Args>(args)...), params_{params} {}
+  explicit OmnidirectionalDriveModel(const param_type& params) : params_{params} {}
 
   /// Applies the last motion update to the given particle state.
   /**
@@ -121,7 +114,7 @@ class OmnidirectionalDriveModel : public Mixin {
   }
 
   /// \copydoc OdometryMotionModelInterface2d::update_motion(const Sophus::SE2d&)
-  void update_motion(const update_type& pose) final {
+  void update_motion(const update_type& pose) {
     if (last_pose_) {
       const auto translation = pose.translation() - last_pose_.value().translation();
       const double distance = translation.norm();
diff --git a/beluga/include/beluga/motion/stationary_model.hpp b/beluga/include/beluga/motion/stationary_model.hpp
index c6c9704bf..6c45f6745 100644
--- a/beluga/include/beluga/motion/stationary_model.hpp
+++ b/beluga/include/beluga/motion/stationary_model.hpp
@@ -34,25 +34,14 @@ namespace beluga {
  *
  * It ignores all odometry updates and only adds Gaussian noise to the
  * input states.
- *
- * \tparam Mixin The mixed-in type with no particular requirements.
  */
-template <class Mixin>
-class StationaryModel : public Mixin {
+class StationaryModel {
  public:
   /// Update type of the motion model.
   using update_type = Sophus::SE2d;
   /// State type of a particle.
   using state_type = Sophus::SE2d;
 
-  /// Constructs a StationaryModel instance.
-  /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
-   * \param ...args Arguments that are not used by this part of the mixin, but by others.
-   */
-  template <class... Args>
-  explicit StationaryModel(Args&&... args) : Mixin(std::forward<Args>(args)...) {}
-
   /// Applies motion to the given particle state.
   /**
    * The updated state will be centered around `state` with some covariance.
@@ -75,7 +64,7 @@ class StationaryModel : public Mixin {
    *
    * For this model, odometry updates are ignored.
    */
-  void update_motion([[maybe_unused]] const update_type& pose) final {}
+  void update_motion([[maybe_unused]] const update_type& pose) {}
 };
 
 }  // namespace beluga
diff --git a/beluga/include/beluga/sensor/beam_model.hpp b/beluga/include/beluga/sensor/beam_model.hpp
index cbd5cca9d..6ea629822 100644
--- a/beluga/include/beluga/sensor/beam_model.hpp
+++ b/beluga/include/beluga/sensor/beam_model.hpp
@@ -63,12 +63,11 @@ struct BeamModelParam {
  *
  * See Probabilistic Robotics \cite thrun2005probabilistic Chapter 6.2.
  *
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam OccupancyGrid Type representing an occupancy grid.
  *  It must satisfy \ref OccupancyGrid2Page.
  */
-template <class Mixin, class OccupancyGrid>
-class BeamSensorModel : public Mixin {
+template <class OccupancyGrid>
+class BeamSensorModel {
  public:
   /// State type of a particle.
   using state_type = Sophus::SE2d;
@@ -76,24 +75,19 @@ class BeamSensorModel : public Mixin {
   using weight_type = double;
   /// Measurement type of the sensor: a point cloud for the range finder.
   using measurement_type = std::vector<std::pair<double, double>>;
-
+  /// Map representation type.
+  using map_type = OccupancyGrid;
   /// Parameter type that the constructor uses to configure the beam sensor model.
   using param_type = BeamModelParam;
 
   /// Constructs a BeamSensorModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance.
    *  See beluga::BeamModelParams for details.
    * \param grid Occupancy grid representing the static map.
-   * \param ...rest Arguments that are not used by this part of the mixin, but by others.
    */
-  template <class... Args>
-  explicit BeamSensorModel(const param_type& params, OccupancyGrid grid, Args&&... rest)
-      : Mixin(std::forward<Args>(rest)...),
-        params_{params},
-        grid_{std::move(grid)},
-        free_states_{compute_free_states(grid_)} {}
+  explicit BeamSensorModel(const param_type& params, OccupancyGrid grid)
+      : params_{params}, grid_{std::move(grid)}, free_states_{compute_free_states(grid_)} {}
 
   // TODO(ivanpauno): is sensor model the best place for this?
   // Maybe the map could be provided by a different part of the mixin,
@@ -166,10 +160,10 @@ class BeamSensorModel : public Mixin {
   }
 
   /// \copydoc LaserSensorModelInterface2d::update_sensor(measurement_type&& points)
-  void update_sensor(measurement_type&& points) final { points_ = std::move(points); }
+  void update_sensor(measurement_type&& points) { points_ = std::move(points); }
 
   /// \copydoc LaserSensorModelInterface2d::update_map(Map&& map)
-  void update_map(OccupancyGrid&& map) final {
+  void update_map(map_type&& map) {
     grid_ = std::move(map);
     free_states_ = compute_free_states(grid_);
   }
diff --git a/beluga/include/beluga/sensor/bearing_sensor_model.hpp b/beluga/include/beluga/sensor/bearing_sensor_model.hpp
index 70fc85f4b..d2c289641 100644
--- a/beluga/include/beluga/sensor/bearing_sensor_model.hpp
+++ b/beluga/include/beluga/sensor/bearing_sensor_model.hpp
@@ -48,12 +48,11 @@ struct BearingModelParam {
 /**
  * This class implements the BearingSensorModelInterface interface
  * and satisfies \ref SensorModelPage.
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  * \tparam StateType type of the state of the particle.
  */
-template <class Mixin, class LandmarkMap, class StateType>
-class BearingSensorModel : public Mixin {
+template <class LandmarkMap, class StateType>
+class BearingSensorModel {
  public:
   /// State type of a particle.
   using state_type = StateType;
@@ -61,20 +60,20 @@ class BearingSensorModel : public Mixin {
   using weight_type = double;
   /// Measurement type of the sensor: vector of landmark detections
   using measurement_type = std::vector<LandmarkBearingDetection>;
+  /// Map representation type.
+  using map_type = LandmarkMap;
   /// Parameter type that the constructor uses to configure the bearing sensor model.
   using param_type = BearingModelParam;
 
   /// Constructs a BearingSensorModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance. See beluga::BearingModelParam for details.
    * \param landmark_map Map of landmarks to be used by this sensor model.
-   * \param ...rest Arguments that are not used by this part of the mixin, but
    * by others.
    */
   template <class... Args>
-  explicit BearingSensorModel(param_type params, LandmarkMap landmark_map, Args&&... rest)
-      : Mixin(std::forward<Args>(rest)...), params_{std::move(params)}, landmark_map_{std::move(landmark_map)} {}
+  explicit BearingSensorModel(param_type params, LandmarkMap landmark_map)
+      : params_{std::move(params)}, landmark_map_{std::move(landmark_map)} {}
 
   /**
    * The generated state is an unoccupied cell of the grid, any free cell is
@@ -167,10 +166,10 @@ class BearingSensorModel : public Mixin {
   }
 
   /// \copydoc BearingSensorModelInterface::update_sensor(measurement_type&&points)
-  void update_sensor(measurement_type&& points) final { points_ = std::move(points); }
+  void update_sensor(measurement_type&& points) { points_ = std::move(points); }
 
   /// \copydoc BearingSensorModelInterface::update_map(Map&& map)
-  void update_map(LandmarkMap&& map) final { landmark_map_ = std::move(map); }
+  void update_map(map_type&& map) { landmark_map_ = std::move(map); }
 
  private:
   param_type params_;
@@ -182,21 +181,19 @@ class BearingSensorModel : public Mixin {
 /**
  * This class implements the BearingSensorModelInterface interface
  * and satisfies \ref SensorModelPage.
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  */
-template <class Mixin, class LandmarkMap>
-using BearingSensorModel2d = BearingSensorModel<Mixin, LandmarkMap, Sophus::SE2d>;
+template <class LandmarkMap>
+using BearingSensorModel2d = BearingSensorModel<LandmarkMap, Sophus::SE2d>;
 
 /// Sensor model based on discrete landmarks bearing detection for 3D state types.
 /**
  * This class implements the BearingSensorModelInterface interface
  * and satisfies \ref SensorModelPage.
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  */
-template <class Mixin, class LandmarkMap>
-using BearingSensorModel3d = BearingSensorModel<Mixin, LandmarkMap, Sophus::SE3d>;
+template <class LandmarkMap>
+using BearingSensorModel3d = BearingSensorModel<LandmarkMap, Sophus::SE3d>;
 
 }  // namespace beluga
 
diff --git a/beluga/include/beluga/sensor/landmark_sensor_model.hpp b/beluga/include/beluga/sensor/landmark_sensor_model.hpp
index 5ea7d94fc..f743023f5 100644
--- a/beluga/include/beluga/sensor/landmark_sensor_model.hpp
+++ b/beluga/include/beluga/sensor/landmark_sensor_model.hpp
@@ -54,12 +54,11 @@ struct LandmarkModelParam {
  * This sensor model is a generalization of the model described in Probabilistic
  * Robotics \cite thrun2005probabilistic Chapter 6.6 .
  *
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  * \tparam StateType type of the state of the particle.
  */
-template <class Mixin, class LandmarkMap, class StateType>
-class LandmarkSensorModel : public Mixin {
+template <class LandmarkMap, class StateType>
+class LandmarkSensorModel {
  public:
   /// State type of a particle.
   using state_type = StateType;
@@ -67,20 +66,19 @@ class LandmarkSensorModel : public Mixin {
   using weight_type = double;
   /// Measurement type of the sensor, detection position in robot frame
   using measurement_type = std::vector<LandmarkPositionDetection>;
+  /// Map representation type.
+  using map_type = LandmarkMap;
   /// Parameter type that the constructor uses to configure the beam sensor model.
   using param_type = LandmarkModelParam;
 
   /// Constructs a LandmarkSensorModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance.
    *  See beluga::BeamModelParams for details.
    * \param landmark_map Map of landmarks to be used by this sensor model.
-   * \param ...rest Arguments that are not used by this part of the mixin, but by others.
    */
-  template <class... Args>
-  explicit LandmarkSensorModel(param_type params, LandmarkMap landmark_map, Args&&... rest)
-      : Mixin(std::forward<Args>(rest)...), params_{std::move(params)}, landmark_map_{std::move(landmark_map)} {}
+  explicit LandmarkSensorModel(param_type params, LandmarkMap landmark_map)
+      : params_{std::move(params)}, landmark_map_{std::move(landmark_map)} {}
 
   /**
    * The generated state is an unoccupied cell of the grid, any free cell is
@@ -185,10 +183,10 @@ class LandmarkSensorModel : public Mixin {
   }
 
   /// \copydoc LandmarkSensorModelInterface::update_sensor(measurement_type&&points)
-  void update_sensor(measurement_type&& points) final { points_ = std::move(points); }
+  void update_sensor(measurement_type&& points) { points_ = std::move(points); }
 
   /// \copydoc LandmarkSensorModelInterface::update_map(Map&& map)
-  void update_map(LandmarkMap&& map) final { landmark_map_ = std::move(map); }
+  void update_map(map_type&& map) { landmark_map_ = std::move(map); }
 
  private:
   param_type params_;
@@ -200,21 +198,19 @@ class LandmarkSensorModel : public Mixin {
 /**
  * This class implements the BearingSensorModelInterface interface
  * and satisfies \ref SensorModelPage.
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  */
-template <class Mixin, class LandmarkMap>
-using LandmarkSensorModel2d = LandmarkSensorModel<Mixin, LandmarkMap, Sophus::SE2d>;
+template <class LandmarkMap>
+using LandmarkSensorModel2d = LandmarkSensorModel<LandmarkMap, Sophus::SE2d>;
 
 /// Sensor model based on discrete landmarks for 3D state types.
 /**
  * This class implements the BearingSensorModelInterface interface
  * and satisfies \ref SensorModelPage.
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam LandmarkMap class managing the list of known landmarks.
  */
-template <class Mixin, class LandmarkMap>
-using LandmarkSensorModel3d = LandmarkSensorModel<Mixin, LandmarkMap, Sophus::SE3d>;
+template <class LandmarkMap>
+using LandmarkSensorModel3d = LandmarkSensorModel<LandmarkMap, Sophus::SE3d>;
 
 }  // namespace beluga
 
diff --git a/beluga/include/beluga/sensor/likelihood_field_model.hpp b/beluga/include/beluga/sensor/likelihood_field_model.hpp
index ae156c862..5ae32dc0a 100644
--- a/beluga/include/beluga/sensor/likelihood_field_model.hpp
+++ b/beluga/include/beluga/sensor/likelihood_field_model.hpp
@@ -67,12 +67,11 @@ struct LikelihoodFieldModelParam {
  *
  * See Probabilistic Robotics \cite thrun2005probabilistic Chapter 6.4.
  *
- * \tparam Mixin The mixed-in type with no particular requirements.
  * \tparam OccupancyGrid Type representing an occupancy grid.
  *  It must satisfy \ref OccupancyGrid2Page.
  */
-template <class Mixin, class OccupancyGrid>
-class LikelihoodFieldModel : public Mixin {
+template <class OccupancyGrid>
+class LikelihoodFieldModel {
  public:
   /// State type of a particle.
   using state_type = Sophus::SE2d;
@@ -80,22 +79,19 @@ class LikelihoodFieldModel : public Mixin {
   using weight_type = double;
   /// Measurement type of the sensor: a point cloud for the range finder.
   using measurement_type = std::vector<std::pair<double, double>>;
-
+  /// Map representation type.
+  using map_type = OccupancyGrid;
   /// Parameter type that the constructor uses to configure the likelihood field model.
   using param_type = LikelihoodFieldModelParam;
 
   /// Constructs a LikelihoodFieldModel instance.
   /**
-   * \tparam ...Args Arguments types for the remaining mixin constructors.
    * \param params Parameters to configure this instance.
    *  See beluga::LikelihoodFieldModelParam for details.
    * \param grid Occupancy grid representing the static map.
-   * \param ...rest Arguments that are not used by this part of the mixin, but by others.
    */
-  template <class... Args>
-  explicit LikelihoodFieldModel(const param_type& params, OccupancyGrid grid, Args&&... rest)
-      : Mixin(std::forward<Args>(rest)...),
-        params_{params},
+  explicit LikelihoodFieldModel(const param_type& params, OccupancyGrid grid)
+      : params_{params},
         grid_{std::move(grid)},
         free_states_{compute_free_states(grid_)},
         likelihood_field_{make_likelihood_field(params, grid_)} {}
@@ -153,10 +149,10 @@ class LikelihoodFieldModel : public Mixin {
   }
 
   /// \copydoc LaserSensorModelInterface2d::update_sensor(measurement_type&& points)
-  void update_sensor(measurement_type&& points) final { points_ = std::move(points); }
+  void update_sensor(measurement_type&& points) { points_ = std::move(points); }
 
   /// \copydoc LaserSensorModelInterface2d::update_map(Map&& map)
-  void update_map(OccupancyGrid&& map) final {
+  void update_map(map_type&& map) {
     grid_ = std::move(map);
     free_states_ = compute_free_states(grid_);
     likelihood_field_ = make_likelihood_field(params_, grid_);
diff --git a/beluga/test/beluga/CMakeLists.txt b/beluga/test/beluga/CMakeLists.txt
index 5ed44a82e..a32973352 100644
--- a/beluga/test/beluga/CMakeLists.txt
+++ b/beluga/test/beluga/CMakeLists.txt
@@ -22,11 +22,9 @@ add_executable(
   algorithm/test_estimation.cpp
   algorithm/test_exponential_filter.cpp
   algorithm/test_raycasting.cpp
-  mixin/test_descriptor.cpp
   mixin/test_particle_filter.cpp
   mixin/test_sampling.cpp
   mixin/test_storage.cpp
-  mixin/test_utility.cpp
   motion/test_differential_drive_model.cpp
   motion/test_omnidirectional_drive_model.cpp
   random/test_multivariate_normal_distribution.cpp
@@ -40,7 +38,6 @@ add_executable(
   sensor/test_bearing_sensor_model.cpp
   sensor/test_landmark_sensor_model.cpp
   sensor/test_likelihood_field_model.cpp
-  test_mixin.cpp
   test_primitives.cpp
   test_spatial_hash.cpp
   test_tuple_vector.cpp
diff --git a/beluga/test/beluga/mixin/test_descriptor.cpp b/beluga/test/beluga/mixin/test_descriptor.cpp
deleted file mode 100644
index 4c97ff01f..000000000
--- a/beluga/test/beluga/mixin/test_descriptor.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2023 Ekumen, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gmock/gmock.h>
-
-#include <beluga/mixin/descriptor.hpp>
-
-namespace {
-
-template <class Mixin>
-struct MyComponent {};
-
-struct MyComponentParam {};
-
-using Descriptor = beluga::mixin::descriptor<MyComponent>;
-using DescriptorWithParams = beluga::mixin::descriptor<MyComponent, MyComponentParam>;
-
-struct StructWithParams {
-  int params;
-};
-
-struct StructWithParamsMethod {
-  int params();
-};
-
-template <class... Descriptors>
-struct CombinedMixins {};
-
-TEST(Descriptor, IsDescriptor) {
-  static_assert(beluga::mixin::is_descriptor_v<Descriptor>);
-  static_assert(beluga::mixin::is_descriptor_v<DescriptorWithParams>);
-  static_assert(!beluga::mixin::is_descriptor_v<int>);
-  static_assert(!beluga::mixin::is_descriptor_v<MyComponentParam>);
-}
-
-TEST(Descriptor, HasParams) {
-  static_assert(!beluga::mixin::has_params_v<Descriptor>);
-  static_assert(beluga::mixin::has_params_v<DescriptorWithParams>);
-  static_assert(!beluga::mixin::has_params_v<int>);
-  static_assert(!beluga::mixin::has_params_v<MyComponentParam>);
-  static_assert(beluga::mixin::has_params_v<StructWithParams>);
-  static_assert(!beluga::mixin::has_params_v<StructWithParamsMethod>);
-}
-
-TEST(Descriptor, MixinFromDescriptors) {
-  using Expected = CombinedMixins<Descriptor, DescriptorWithParams>;
-  using FirstMixin = beluga::mixin::mixin_from_descriptors_t<CombinedMixins, Descriptor, DescriptorWithParams>;
-  using SecondMixin = beluga::mixin::mixin_from_descriptors_t<CombinedMixins, Descriptor&, const DescriptorWithParams&>;
-  using ThirdMixin =
-      beluga::mixin::mixin_from_descriptors_t<CombinedMixins, std::tuple<Descriptor&, const DescriptorWithParams&>>;
-  static_assert(std::is_same_v<Expected, FirstMixin>);
-  static_assert(std::is_same_v<Expected, SecondMixin>);
-  static_assert(std::is_same_v<Expected, ThirdMixin>);
-}
-
-}  // namespace
diff --git a/beluga/test/beluga/mixin/test_utility.cpp b/beluga/test/beluga/mixin/test_utility.cpp
deleted file mode 100644
index 571301cf9..000000000
--- a/beluga/test/beluga/mixin/test_utility.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2023 Ekumen, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gmock/gmock.h>
-
-#include <beluga/mixin/utility.hpp>
-
-namespace {
-
-struct Object {};
-
-TEST(Filter, FilterWithPredicate) {
-  using arithmetic_list = beluga::mixin::filter<std::is_arithmetic, beluga::mixin::list<int, float, Object, bool>>;
-  static_assert(std::is_same_v<arithmetic_list, beluga::mixin::list<int, float, bool>>);
-  static_assert(
-      std::is_same_v<
-          beluga::mixin::filter<std::is_void, beluga::mixin::list<int, float, Object, bool>>, beluga::mixin::list<>>);
-}
-
-TEST(IsVariant, Qualified) {
-  static_assert(beluga::mixin::is_variant_v<std::variant<int>>);
-  static_assert(beluga::mixin::is_variant_v<const std::variant<int>&>);
-  static_assert(beluga::mixin::is_variant_v<volatile std::variant<int>>);
-
-  static_assert(!beluga::mixin::is_variant_v<std::variant<int>*>);
-  static_assert(!beluga::mixin::is_variant_v<int>);
-  static_assert(!beluga::mixin::is_variant_v<Object>);
-}
-
-TEST(IsReferenceWrapper, Qualified) {
-  static_assert(beluga::mixin::is_reference_wrapper_v<std::reference_wrapper<int>>);
-  static_assert(beluga::mixin::is_reference_wrapper_v<const std::reference_wrapper<int>&>);
-  static_assert(beluga::mixin::is_reference_wrapper_v<volatile std::reference_wrapper<int>>);
-
-  static_assert(!beluga::mixin::is_reference_wrapper_v<std::reference_wrapper<int>*>);
-  static_assert(!beluga::mixin::is_reference_wrapper_v<int>);
-  static_assert(!beluga::mixin::is_reference_wrapper_v<Object>);
-}
-
-TEST(MaybeUnwrap, PassingReferenceWrapper) {
-  auto mutable_object = Object{};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_unwrap(std::ref(mutable_object))), Object&>);
-  const auto const_object = Object{};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_unwrap(std::ref(const_object))), const Object&>);
-  int value = 540;
-  ASSERT_EQ(beluga::mixin::maybe_unwrap(std::ref(value)), 540);
-}
-
-TEST(MaybeUnwrap, PassingNonReferenceWrapper) {
-  auto mutable_object = Object{};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_unwrap(mutable_object)), Object&>);
-  const auto const_object = Object{};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_unwrap(const_object)), const Object&>);
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_unwrap(Object{})), Object&&>);
-  ASSERT_EQ(beluga::mixin::maybe_unwrap(530), 530);
-}
-
-TEST(MaybeVariant, PassingVariant) {
-  using variant_type = std::variant<int, float>;
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(variant_type{100})), variant_type&&>);
-  auto mutable_object = variant_type{1.0F};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(mutable_object)), variant_type&>);
-  const auto const_object = variant_type{2.0F};
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(const_object)), const variant_type&>);
-}
-
-TEST(MaybeVariant, PassingNonVariant) {
-  using type = std::variant<std::reference_wrapper<float>>;
-  float mutable_object = 2.0F;
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(mutable_object)), type>);
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(std::move(mutable_object))), type>);
-  static_assert(std::is_same_v<decltype(beluga::mixin::maybe_variant(100.0F)), type>);
-}
-
-TEST(VisitEverything, VariantAndValues) {
-  int value = 5;
-  auto variant = std::variant<int, std::int64_t>{2};
-  const auto sum_to_int64 = [](auto v1, auto v2) -> std::int64_t { return v1 + v2; };
-  ASSERT_EQ(beluga::mixin::visit_everything(sum_to_int64, variant, value), 7);
-  ASSERT_EQ(beluga::mixin::visit_everything(sum_to_int64, 10, value), 15);
-  ASSERT_EQ(beluga::mixin::visit_everything(sum_to_int64, variant, 10), 12);
-}
-
-TEST(VisitEverything, FowardSingleParameter) {
-  const auto forward = [](auto&& value) -> auto&& { return value; };
-  int value = 5;
-  int& alias = beluga::mixin::visit_everything(forward, value);
-  ASSERT_EQ(alias, 5);
-  alias = 6;
-  ASSERT_EQ(value, 6);
-}
-
-template <typename T>
-using is_object = std::is_same<std::decay_t<T>, Object>;
-
-template <typename T>
-using is_arithmetic_decay = std::is_arithmetic<std::decay_t<T>>;
-
-TEST(MakeTupleWith, Values) {
-  int mutable_value = 4;
-  const int const_value = 5;
-  auto tuple1 = beluga::mixin::make_tuple_with<is_object>(1., mutable_value, const_value, Object{});
-  auto tuple2 = beluga::mixin::make_tuple_with<is_arithmetic_decay>(1., mutable_value, const_value, Object{});
-  static_assert(std::is_same_v<decltype(tuple1), std::tuple<Object&&>>);
-  static_assert(std::is_same_v<decltype(tuple2), std::tuple<double&&, int&, const int&>>);
-  int& alias = std::get<int&>(tuple2);
-  ASSERT_EQ(alias, 4);
-  alias = 6;
-  ASSERT_EQ(mutable_value, 6);
-}
-
-}  // namespace
diff --git a/beluga/test/beluga/motion/test_differential_drive_model.cpp b/beluga/test/beluga/motion/test_differential_drive_model.cpp
index 76df6a2e4..d13712018 100644
--- a/beluga/test/beluga/motion/test_differential_drive_model.cpp
+++ b/beluga/test/beluga/motion/test_differential_drive_model.cpp
@@ -29,57 +29,56 @@ using Eigen::Vector2d;
 using Sophus::SE2d;
 using Sophus::SO2d;
 
-using UUT =
-    ciabatta::mixin<beluga::DifferentialDriveModel, ciabatta::provides<beluga::OdometryMotionModelInterface2d>::mixin>;
+using UUT = beluga::DifferentialDriveModel;
 
 class DifferentialDriveModelTest : public ::testing::Test {
  protected:
-  UUT mixin_{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, 0.0}};  // No variance
+  UUT model_{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, 0.0}};  // No variance
   std::mt19937 generator_{std::random_device()()};
 };
 
 TEST_F(DifferentialDriveModelTest, NoUpdate) {
   const auto pose = SE2d{SO2d{Constants::pi() / 3}, Vector2d{2.0, 5.0}};
-  ASSERT_THAT(mixin_.apply_motion(pose, generator_), testing::SE2Eq(pose));
+  ASSERT_THAT(model_.apply_motion(pose, generator_), testing::SE2Eq(pose));
 }
 
 TEST_F(DifferentialDriveModelTest, OneUpdate) {
   const auto pose = SE2d{SO2d{Constants::pi() / 3}, Vector2d{2.0, 5.0}};
-  mixin_.update_motion(SE2d{SO2d{Constants::pi()}, Vector2d{1.0, -2.0}});
-  ASSERT_THAT(mixin_.apply_motion(pose, generator_), testing::SE2Eq(pose));
+  model_.update_motion(SE2d{SO2d{Constants::pi()}, Vector2d{1.0, -2.0}});
+  ASSERT_THAT(model_.apply_motion(pose, generator_), testing::SE2Eq(pose));
 }
 
 TEST_F(DifferentialDriveModelTest, Translate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 0.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{2.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 0.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{2.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{0.0}, Vector2d{3.0, 0.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 3.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 3.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{0.0}, Vector2d{1.0, 3.0}));
 }
 
 TEST_F(DifferentialDriveModelTest, RotateTranslate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{2.0, 3.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{2.0, 3.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{0.0}, Vector2d{3.0, 3.0}));
 }
 
 TEST_F(DifferentialDriveModelTest, Rotate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{Constants::pi() / 4}, Vector2d{0.0, 0.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{0.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{Constants::pi() / 4}, Vector2d{0.0, 0.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{Constants::pi() * 5 / 4}, Vector2d{0.0, 0.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{0.0, 0.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{-Constants::pi() / 4}, Vector2d{0.0, 0.0}));
 }
 
 TEST_F(DifferentialDriveModelTest, RotateTranslateRotate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{1.0, 2.0}});
-  const auto result = mixin_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{3.0, 4.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{1.0, 2.0}});
+  const auto result = model_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{3.0, 4.0}}, generator_);
   ASSERT_THAT(result, testing::SE2Eq(SO2d{Constants::pi() / 2}, Vector2d{2.0, 2.0}));
 }
 
@@ -101,12 +100,12 @@ TEST(DifferentialDriveModelSamples, Translate) {
   const double alpha = 0.2;
   const double origin = 5.0;
   const double distance = 3.0;
-  auto mixin = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, alpha, 0.0}};  // Translation variance
+  auto model = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, alpha, 0.0}};  // Translation variance
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{distance, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{distance, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{0.0}, Vector2d{origin, 0.0}}, generator).translation().x();
+                return model.apply_motion(SE2d{SO2d{0.0}, Vector2d{origin, 0.0}}, generator).translation().x();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -118,12 +117,12 @@ TEST(DifferentialDriveModelSamples, RotateFirstQuadrant) {
   const double alpha = 0.2;
   const double initial_angle = Constants::pi() / 6;
   const double motion_angle = Constants::pi() / 4;
-  auto mixin = UUT{beluga::DifferentialDriveModelParam{alpha, 0.0, 0.0, 0.0}};  // Rotation variance
+  auto model = UUT{beluga::DifferentialDriveModelParam{alpha, 0.0, 0.0, 0.0}};  // Rotation variance
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
+                return model.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -135,12 +134,12 @@ TEST(DifferentialDriveModelSamples, RotateThirdQuadrant) {
   const double alpha = 0.2;
   const double initial_angle = Constants::pi() / 6;
   const double motion_angle = -Constants::pi() * 3 / 4;
-  auto mixin = UUT{beluga::DifferentialDriveModelParam{alpha, 0.0, 0.0, 0.0}};  // Rotation variance
+  auto model = UUT{beluga::DifferentialDriveModelParam{alpha, 0.0, 0.0, 0.0}};  // Rotation variance
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
+                return model.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -153,12 +152,12 @@ TEST(DifferentialDriveModelSamples, RotateThirdQuadrant) {
 
 TEST(DifferentialDriveModelSamples, RotateTranslateRotateFirstQuadrant) {
   const double alpha = 0.2;
-  auto mixin = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, alpha}};  // Translation variance from rotation
+  auto model = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, alpha}};  // Translation variance from rotation
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 1.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 1.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator).translation().norm();
+                return model.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator).translation().norm();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -175,12 +174,12 @@ TEST(DifferentialDriveModelSamples, RotateTranslateRotateFirstQuadrant) {
 
 TEST(DifferentialDriveModelSamples, RotateTranslateRotateThirdQuadrant) {
   const double alpha = 0.2;
-  auto mixin = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, alpha}};  // Translation variance from rotation
+  auto model = UUT{beluga::DifferentialDriveModelParam{0.0, 0.0, 0.0, alpha}};  // Translation variance from rotation
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{-1.0, -1.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{-1.0, -1.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator).translation().norm();
+                return model.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator).translation().norm();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
diff --git a/beluga/test/beluga/motion/test_omnidirectional_drive_model.cpp b/beluga/test/beluga/motion/test_omnidirectional_drive_model.cpp
index 2f16c704a..3edcb31c4 100644
--- a/beluga/test/beluga/motion/test_omnidirectional_drive_model.cpp
+++ b/beluga/test/beluga/motion/test_omnidirectional_drive_model.cpp
@@ -15,7 +15,6 @@
 #include <gmock/gmock.h>
 
 #include <beluga/motion.hpp>
-#include <ciabatta/ciabatta.hpp>
 #include <range/v3/view/common.hpp>
 #include <range/v3/view/generate.hpp>
 #include <range/v3/view/take_exactly.hpp>
@@ -29,57 +28,56 @@ using Eigen::Vector2d;
 using Sophus::SE2d;
 using Sophus::SO2d;
 
-using UUT = ciabatta::
-    mixin<beluga::OmnidirectionalDriveModel, ciabatta::provides<beluga::OdometryMotionModelInterface2d>::mixin>;
+using UUT = beluga::OmnidirectionalDriveModel;
 
 class OmnidirectionalDriveModelTest : public ::testing::Test {
  protected:
-  UUT mixin_{beluga::OmnidirectionalDriveModelParam{0.0, 0.0, 0.0, 0.0, 0.0}};  // No variance
+  UUT model_{beluga::OmnidirectionalDriveModelParam{0.0, 0.0, 0.0, 0.0, 0.0}};  // No variance
   std::mt19937 generator_{std::random_device()()};
 };
 
 TEST_F(OmnidirectionalDriveModelTest, NoUpdate) {
   const auto pose = SE2d{SO2d{Constants::pi() / 3}, Vector2d{2.0, 5.0}};
-  ASSERT_THAT(mixin_.apply_motion(pose, generator_), testing::SE2Eq(pose));
+  ASSERT_THAT(model_.apply_motion(pose, generator_), testing::SE2Eq(pose));
 }
 
 TEST_F(OmnidirectionalDriveModelTest, OneUpdate) {
   const auto pose = SE2d{SO2d{Constants::pi() / 3}, Vector2d{2.0, 5.0}};
-  mixin_.update_motion(SE2d{SO2d{Constants::pi()}, Vector2d{1.0, -2.0}});
-  ASSERT_THAT(mixin_.apply_motion(pose, generator_), testing::SE2Eq(pose));
+  model_.update_motion(SE2d{SO2d{Constants::pi()}, Vector2d{1.0, -2.0}});
+  ASSERT_THAT(model_.apply_motion(pose, generator_), testing::SE2Eq(pose));
 }
 
 TEST_F(OmnidirectionalDriveModelTest, Translate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 0.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{2.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{1.0, 0.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{2.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{0.0}, Vector2d{3.0, 0.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 3.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 3.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{0.0}, Vector2d{1.0, 3.0}));
 }
 
 TEST_F(OmnidirectionalDriveModelTest, RotateTranslate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{Constants::pi() / 2}, Vector2d{0.0, 1.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{2.0, 3.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{2.0, 3.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{0.0}, Vector2d{3.0, 3.0}));
 }
 
 TEST_F(OmnidirectionalDriveModelTest, Rotate) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{Constants::pi() / 4}, Vector2d{0.0, 0.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{0.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{Constants::pi() / 4}, Vector2d{0.0, 0.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{Constants::pi()}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{Constants::pi() * 5 / 4}, Vector2d{0.0, 0.0}));
-  const auto result2 = mixin_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{0.0, 0.0}}, generator_);
+  const auto result2 = model_.apply_motion(SE2d{SO2d{-Constants::pi() / 2}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result2, testing::SE2Eq(SO2d{-Constants::pi() / 4}, Vector2d{0.0, 0.0}));
 }
 
 TEST_F(OmnidirectionalDriveModelTest, TranslateStrafe) {
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 1.0}});
-  const auto result1 = mixin_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model_.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 1.0}});
+  const auto result1 = model_.apply_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}}, generator_);
   ASSERT_THAT(result1, testing::SE2Eq(SO2d{0.0}, Vector2d{0.0, 1.0}));
 }
 
@@ -101,12 +99,12 @@ TEST(OmnidirectionalDriveModelSamples, Translate) {
   const double alpha = 0.2;
   const double origin = 5.0;
   const double distance = 3.0;
-  auto mixin = UUT{beluga::OmnidirectionalDriveModelParam{0.0, 0.0, alpha, 0.0, 0.0}};  // Translation variance
+  auto model = UUT{beluga::OmnidirectionalDriveModelParam{0.0, 0.0, alpha, 0.0, 0.0}};  // Translation variance
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{distance, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{distance, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{0.0}, Vector2d{origin, 0.0}}, generator).translation().x();
+                return model.apply_motion(SE2d{SO2d{0.0}, Vector2d{origin, 0.0}}, generator).translation().x();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -118,12 +116,12 @@ TEST(OmnidirectionalDriveModelSamples, RotateFirstQuadrant) {
   const double alpha = 0.2;
   const double initial_angle = Constants::pi() / 6;
   const double motion_angle = Constants::pi() / 4;
-  auto mixin = UUT{beluga::OmnidirectionalDriveModelParam{alpha, 0.0, 0.0, 0.0, 0.0}};
+  auto model = UUT{beluga::OmnidirectionalDriveModelParam{alpha, 0.0, 0.0, 0.0, 0.0}};
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
+                return model.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
@@ -135,12 +133,12 @@ TEST(OmnidirectionalDriveModelSamples, RotateThirdQuadrant) {
   const double alpha = 0.2;
   const double initial_angle = Constants::pi() / 6;
   const double motion_angle = -Constants::pi() * 3 / 4;
-  auto mixin = UUT{beluga::OmnidirectionalDriveModelParam{alpha, 0.0, 0.0, 0.0, 0.0}};
+  auto model = UUT{beluga::OmnidirectionalDriveModelParam{alpha, 0.0, 0.0, 0.0, 0.0}};
   auto generator = std::mt19937{std::random_device()()};
-  mixin.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
-  mixin.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{0.0}, Vector2d{0.0, 0.0}});
+  model.update_motion(SE2d{SO2d{motion_angle}, Vector2d{0.0, 0.0}});
   auto view = ranges::views::generate([&]() {
-                return mixin.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
+                return model.apply_motion(SE2d{SO2d{initial_angle}, Vector2d{0.0, 0.0}}, generator).so2().log();
               }) |
               ranges::views::take_exactly(1'000'000) | ranges::views::common;
   const auto [mean, stddev] = get_statistics(view);
diff --git a/beluga/test/beluga/sensor/test_beam_model.cpp b/beluga/test/beluga/sensor/test_beam_model.cpp
index db4a7e9b3..a96d03fc5 100644
--- a/beluga/test/beluga/sensor/test_beam_model.cpp
+++ b/beluga/test/beluga/sensor/test_beam_model.cpp
@@ -25,9 +25,7 @@ namespace beluga {
 
 using beluga::testing::StaticOccupancyGrid;
 
-using UUT = ciabatta::mixin<
-    ciabatta::curry<beluga::BeamSensorModel, StaticOccupancyGrid<5, 5>>::mixin,
-    ciabatta::provides<beluga::LaserSensorModelInterface2d<StaticOccupancyGrid<5, 5>>>::mixin>;
+using UUT = beluga::BeamSensorModel<StaticOccupancyGrid<5, 5>>;
 
 BeamModelParam GetParams() {
   BeamModelParam ret;
@@ -53,25 +51,25 @@ TEST(BeamSensorModel, ImportanceWeight) {
   // clang-format on
 
   const auto params = GetParams();
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
   // Perfect hit.
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
-  EXPECT_NEAR(1.0171643824743635, mixin.importance_weight(grid.origin()), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
+  EXPECT_NEAR(1.0171643824743635, model.importance_weight(grid.origin()), 1e-6);
 
   // This is a hit that's before the obstacle, hence is affected by the unexpected obstacle part of the distribution.
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{0.75, 0.75}});
-  EXPECT_NEAR(0.015905891701088148, mixin.importance_weight(grid.origin()), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{0.75, 0.75}});
+  EXPECT_NEAR(0.015905891701088148, model.importance_weight(grid.origin()), 1e-6);
 
   // Hit that's past the obstacle, hence is not affected by the unexpected obstacle part of the distribution.
   // This should be really close to zero.
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{2.25, 2.25}});
-  EXPECT_NEAR(0.000, mixin.importance_weight(grid.origin()), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{2.25, 2.25}});
+  EXPECT_NEAR(0.000, model.importance_weight(grid.origin()), 1e-6);
 
   // Range return longer than beam_max_range, so the max measurement distribution kicks in and this shouldn't be
   // zero.
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{params.beam_max_range, params.beam_max_range}});
-  EXPECT_NEAR(0.00012500000000000003, mixin.importance_weight(grid.origin()), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{params.beam_max_range, params.beam_max_range}});
+  EXPECT_NEAR(0.00012500000000000003, model.importance_weight(grid.origin()), 1e-6);
 }
 
 TEST(BeamSensorModel, GridUpdates) {
@@ -89,10 +87,10 @@ TEST(BeamSensorModel, GridUpdates) {
   // clang-format on
 
   const auto params = GetParams();
-  auto mixin = UUT{params, std::move(grid)};
+  auto model = UUT{params, std::move(grid)};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
-  EXPECT_NEAR(1.0171643824743635, mixin.importance_weight(origin), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
+  EXPECT_NEAR(1.0171643824743635, model.importance_weight(origin), 1e-6);
 
   // clang-format off
   grid = StaticOccupancyGrid<5, 5>{{
@@ -104,10 +102,10 @@ TEST(BeamSensorModel, GridUpdates) {
     kResolution, origin};
   // clang-format on
 
-  mixin.update_map(std::move(grid));
+  model.update_map(std::move(grid));
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
-  EXPECT_NEAR(0.0, mixin.importance_weight(origin), 1e-3);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
+  EXPECT_NEAR(0.0, model.importance_weight(origin), 1e-3);
 }
 
 }  // namespace beluga
diff --git a/beluga/test/beluga/sensor/test_bearing_sensor_model.cpp b/beluga/test/beluga/sensor/test_bearing_sensor_model.cpp
index b533582fa..b277571d5 100644
--- a/beluga/test/beluga/sensor/test_bearing_sensor_model.cpp
+++ b/beluga/test/beluga/sensor/test_bearing_sensor_model.cpp
@@ -28,13 +28,8 @@
 
 namespace beluga {
 
-using Sensor2D = ciabatta::mixin<
-    ciabatta::curry<beluga::BearingSensorModel2d, LandmarkMap>::mixin,
-    ciabatta::provides<beluga::BearingSensorModelInterface<LandmarkMap>>::mixin>;
-
-using Sensor3D = ciabatta::mixin<
-    ciabatta::curry<beluga::BearingSensorModel3d, LandmarkMap>::mixin,
-    ciabatta::provides<beluga::BearingSensorModelInterface<LandmarkMap>>::mixin>;
+using Sensor2D = beluga::BearingSensorModel2d<LandmarkMap>;
+using Sensor3D = beluga::BearingSensorModel3d<LandmarkMap>;
 
 LandmarkMapBoundaries default_map_boundaries{-10.0, -10.0, 10.0, 10.0, 0.0, 0.0};
 
diff --git a/beluga/test/beluga/sensor/test_landmark_sensor_model.cpp b/beluga/test/beluga/sensor/test_landmark_sensor_model.cpp
index 004203b39..a82869dba 100644
--- a/beluga/test/beluga/sensor/test_landmark_sensor_model.cpp
+++ b/beluga/test/beluga/sensor/test_landmark_sensor_model.cpp
@@ -32,13 +32,8 @@ namespace beluga {
 
 namespace {
 
-using Sensor2D = ciabatta::mixin<
-    ciabatta::curry<beluga::LandmarkSensorModel2d, LandmarkMap>::mixin,
-    ciabatta::provides<beluga::LandmarkSensorModelInterface<LandmarkMap>>::mixin>;
-
-using Sensor3D = ciabatta::mixin<
-    ciabatta::curry<beluga::LandmarkSensorModel3d, LandmarkMap>::mixin,
-    ciabatta::provides<beluga::LandmarkSensorModelInterface<LandmarkMap>>::mixin>;
+using Sensor2D = beluga::LandmarkSensorModel2d<LandmarkMap>;
+using Sensor3D = beluga::LandmarkSensorModel3d<LandmarkMap>;
 
 double expected_aggregate_probability(std::vector<double> landmark_probs) {
   // nav2_amcl formula, $1.0 + \sum_{i=1}^n p_i^3$
diff --git a/beluga/test/beluga/sensor/test_likelihood_field_model.cpp b/beluga/test/beluga/sensor/test_likelihood_field_model.cpp
index 6ab3dc152..9aecc2afe 100644
--- a/beluga/test/beluga/sensor/test_likelihood_field_model.cpp
+++ b/beluga/test/beluga/sensor/test_likelihood_field_model.cpp
@@ -23,9 +23,7 @@ namespace {
 
 using beluga::testing::StaticOccupancyGrid;
 
-using UUT = ciabatta::mixin<
-    ciabatta::curry<beluga::LikelihoodFieldModel, StaticOccupancyGrid<5, 5>>::mixin,
-    ciabatta::provides<beluga::LaserSensorModelInterface2d<StaticOccupancyGrid<5, 5>>>::mixin>;
+using UUT = beluga::LikelihoodFieldModel<StaticOccupancyGrid<5, 5>>;
 
 TEST(LikelihoodFieldModel, LikelihoodField) {
   constexpr double kResolution = 0.5;
@@ -48,14 +46,14 @@ TEST(LikelihoodFieldModel, LikelihoodField) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
   // the likelihood field model includes an optimization that stores the likelihood elevated to the cube
   auto expected_cubed_likelihood =
       expected_likelihood_field | ranges::views::transform([](auto v) { return v * v * v; }) | ranges::to<std::vector>;
 
   ASSERT_THAT(
-      mixin.likelihood_field().data(), testing::Pointwise(testing::DoubleNear(0.003), expected_cubed_likelihood));
+      model.likelihood_field().data(), testing::Pointwise(testing::DoubleNear(0.003), expected_cubed_likelihood));
 }
 
 TEST(LikelihoodFieldModel, ImportanceWeight) {
@@ -71,22 +69,22 @@ TEST(LikelihoodFieldModel, ImportanceWeight) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1.25, 1.25}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1.25, 1.25}});
+  ASSERT_NEAR(2.068, model.importance_weight(grid.origin()), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{2.25, 2.25}});
-  ASSERT_NEAR(1.000, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{2.25, 2.25}});
+  ASSERT_NEAR(1.000, model.importance_weight(grid.origin()), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{-50.0, 50.0}});
-  ASSERT_NEAR(1.000, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{-50.0, 50.0}});
+  ASSERT_NEAR(1.000, model.importance_weight(grid.origin()), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1.20, 1.20}, {1.25, 1.25}, {1.30, 1.30}});
-  ASSERT_NEAR(4.205, mixin.importance_weight(grid.origin()), 0.01);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1.20, 1.20}, {1.25, 1.25}, {1.30, 1.30}});
+  ASSERT_NEAR(4.205, model.importance_weight(grid.origin()), 0.01);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{0.0, 0.0}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(Sophus::SE2d{Sophus::SO2d{}, Eigen::Vector2d{1.25, 1.25}}), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{0.0, 0.0}});
+  ASSERT_NEAR(2.068, model.importance_weight(Sophus::SE2d{Sophus::SO2d{}, Eigen::Vector2d{1.25, 1.25}}), 0.003);
 }
 
 TEST(LikelihoodFieldModel, GridWithOffset) {
@@ -103,13 +101,13 @@ TEST(LikelihoodFieldModel, GridWithOffset) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{4.5, 4.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(Sophus::SE2d{}), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{4.5, 4.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(Sophus::SE2d{}), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(grid.origin()), 0.003);
 }
 
 TEST(LikelihoodFieldModel, GridWithRotation) {
@@ -126,13 +124,13 @@ TEST(LikelihoodFieldModel, GridWithRotation) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{-9.5, 9.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(Sophus::SE2d{}), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{-9.5, 9.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(Sophus::SE2d{}), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(grid.origin()), 0.003);
 }
 
 TEST(LikelihoodFieldModel, GridWithRotationAndOffset) {
@@ -152,13 +150,13 @@ TEST(LikelihoodFieldModel, GridWithRotationAndOffset) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, grid};
+  auto model = UUT{params, grid};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{-4.5, 4.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(Sophus::SE2d{}), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{-4.5, 4.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(Sophus::SE2d{}), 0.003);
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
-  ASSERT_NEAR(2.068, mixin.importance_weight(grid.origin()), 0.003);
+  model.update_sensor(std::vector<std::pair<double, double>>{{9.5, 9.5}});
+  ASSERT_NEAR(2.068, model.importance_weight(grid.origin()), 0.003);
 }
 
 TEST(LikelihoodFieldModel, GridUpdates) {
@@ -176,10 +174,10 @@ TEST(LikelihoodFieldModel, GridUpdates) {
   // clang-format on
 
   const auto params = beluga::LikelihoodFieldModelParam{2.0, 20.0, 0.5, 0.5, 0.2};
-  auto mixin = UUT{params, std::move(grid)};
+  auto model = UUT{params, std::move(grid)};
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
-  EXPECT_NEAR(2.068577607986223, mixin.importance_weight(origin), 1e-6);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
+  EXPECT_NEAR(2.068577607986223, model.importance_weight(origin), 1e-6);
 
   // clang-format off
   grid = StaticOccupancyGrid<5, 5>{{
@@ -190,10 +188,10 @@ TEST(LikelihoodFieldModel, GridUpdates) {
     false, false, false, false, true},
     kResolution, origin};
   // clang-format on
-  mixin.update_map(std::move(grid));
+  model.update_map(std::move(grid));
 
-  mixin.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
-  EXPECT_NEAR(1.0, mixin.importance_weight(origin), 1e-3);
+  model.update_sensor(std::vector<std::pair<double, double>>{{1., 1.}});
+  EXPECT_NEAR(1.0, model.importance_weight(origin), 1e-3);
 }
 
 }  // namespace
diff --git a/beluga/test/beluga/test_mixin.cpp b/beluga/test/beluga/test_mixin.cpp
deleted file mode 100644
index d1d6df3fa..000000000
--- a/beluga/test/beluga/test_mixin.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2023 Ekumen, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <gtest/gtest.h>
-
-#include <beluga/mixin.hpp>
-
-/**
- * \file
- * \brief Tests for mixin utilities and extensions.
- */
-
-namespace {
-
-//! [Using make_mixin]
-
-// Common interface for demonstration purposes.
-struct Interface {
-  [[nodiscard]] virtual std::string_view name() const = 0;
-  virtual ~Interface() = default;
-};
-
-// This is a base mixin template that takes two descriptors as parameters.
-template <class First, class Second>
-using Combined = ciabatta::mixin<First::template mixin, Second::template mixin, ciabatta::provides<Interface>::mixin>;
-
-// This is a mixin component without parameters.
-template <class Mixin>
-struct EmptyComponent : public Mixin {
-  template <class... Args>
-  explicit EmptyComponent(Args&&... args) : Mixin(std::forward<Args>(args)...) {}
-};
-
-// This is another mixin component without parameters.
-template <class Mixin>
-struct NameProvider1 : public Mixin {
-  template <class... Args>
-  explicit NameProvider1(Args&&... args) : Mixin(std::forward<Args>(args)...) {}
-
-  [[nodiscard]] std::string_view name() const override { return "One"; }
-};
-
-// This is a mixin component with a single parameter.
-template <class Mixin>
-struct NameProvider2 : public Mixin {
-  template <class... Args>
-  explicit NameProvider2(char, Args&&... args) : Mixin(std::forward<Args>(args)...) {}
-
-  [[nodiscard]] std::string_view name() const override { return "Two"; }
-};
-
-// Descriptor definitions.
-using EmptyComponentDescriptor = beluga::mixin::descriptor<EmptyComponent>;
-using NameProviderDescriptor1 = beluga::mixin::descriptor<NameProvider1>;
-using NameProviderDescriptor2 = beluga::mixin::descriptor<NameProvider2, char>;
-
-TEST(MakeUnique, ExampleBasic) {
-  auto first = EmptyComponentDescriptor{};
-  auto second = NameProviderDescriptor1{};
-  auto ptr = beluga::mixin::make_mixin<Interface, Combined>(first, second);
-  static_assert(std::is_same_v<decltype(ptr), std::unique_ptr<Interface>>);
-  ASSERT_EQ(ptr->name(), "One");
-}
-
-TEST(MakeUnique, ExampleVariants) {
-  auto first = EmptyComponentDescriptor{};
-  auto second = std::variant<NameProviderDescriptor1, NameProviderDescriptor2>{NameProviderDescriptor1{}};
-  auto ptr = beluga::mixin::make_mixin<Interface, Combined>(first, second);
-  static_assert(std::is_same_v<decltype(ptr), std::unique_ptr<Interface>>);
-  ASSERT_EQ(ptr->name(), "One");
-}
-
-TEST(MakeUnique, ExampleParameters) {
-  auto first = EmptyComponentDescriptor{};
-  auto second = NameProviderDescriptor2{'a'};
-  auto ptr = beluga::mixin::make_mixin<Interface, Combined>(first, second);
-  static_assert(std::is_same_v<decltype(ptr), std::unique_ptr<Interface>>);
-  ASSERT_EQ(ptr->name(), "Two");
-}
-
-TEST(MakeUnique, ExampleVariantsAndParameters) {
-  auto first = EmptyComponentDescriptor{};
-  auto second = std::variant<NameProviderDescriptor1, NameProviderDescriptor2>{NameProviderDescriptor2{'a'}};
-  auto ptr = beluga::mixin::make_mixin<Interface, Combined>(first, second);
-  static_assert(std::is_same_v<decltype(ptr), std::unique_ptr<Interface>>);
-  ASSERT_EQ(ptr->name(), "Two");
-}
-
-//! [Using make_mixin]
-
-}  // namespace
diff --git a/beluga_amcl/include/beluga_amcl/particle_filtering.hpp b/beluga_amcl/include/beluga_amcl/particle_filtering.hpp
index abc1b69df..832758921 100644
--- a/beluga_amcl/include/beluga_amcl/particle_filtering.hpp
+++ b/beluga_amcl/include/beluga_amcl/particle_filtering.hpp
@@ -43,41 +43,33 @@ static constexpr std::string_view kBeamSensorModelName = "beam";
 using LaserLocalizationInterface2d =
     beluga::LaserLocalizationInterface2d<beluga_ros::OccupancyGrid, FilterUpdateControlInterface>;
 
-using Stationary = beluga::mixin::descriptor<beluga::StationaryModel>;
-using DifferentialDrive =
-    beluga::mixin::descriptor<beluga::DifferentialDriveModel, beluga::DifferentialDriveModelParam>;
-using OmnidirectionalDrive =
-    beluga::mixin::descriptor<beluga::OmnidirectionalDriveModel, beluga::OmnidirectionalDriveModelParam>;
+using MotionDescriptor = std::variant<  //
+    beluga::StationaryModel,            //
+    beluga::DifferentialDriveModel,     //
+    beluga::OmnidirectionalDriveModel>;
 
-using MotionDescriptor = std::variant<Stationary, DifferentialDrive, OmnidirectionalDrive>;
-
-using LikelihoodField = beluga::mixin::descriptor<
-    ciabatta::curry<beluga::LikelihoodFieldModel, beluga_ros::OccupancyGrid>::mixin,
-    beluga::LikelihoodFieldModelParam>;
-
-using BeamSensorModel = beluga::mixin::
-    descriptor<ciabatta::curry<beluga::BeamSensorModel, beluga_ros::OccupancyGrid>::mixin, beluga::BeamModelParam>;
-
-using SensorDescriptor = std::variant<LikelihoodField, BeamSensorModel>;
+using SensorDescriptor = std::variant<                        //
+    beluga::LikelihoodFieldModel<beluga_ros::OccupancyGrid>,  //
+    beluga::BeamSensorModel<beluga_ros::OccupancyGrid>>;
 
 template <typename Mixin>
 using ConcreteResamplingPoliciesPoller =
     FilterUpdateControlMixin<Mixin, UpdateFilterWhenMovingPolicy, ResampleIntervalPolicy, SelectiveResamplingPolicy>;
 
-template <class MotionDescriptor, class SensorDescriptor>
+template <class MotionModel, class SensorModel>
 using MonteCarloLocalization2d = beluga::MonteCarloLocalization2d<
-    MotionDescriptor,
-    SensorDescriptor,
+    MotionModel,
+    SensorModel,
     beluga_ros::OccupancyGrid,
-    FilterUpdateControlInterface,
+    LaserLocalizationInterface2d,
     ConcreteResamplingPoliciesPoller>;
 
-template <class MotionDescriptor, class SensorDescriptor>
+template <class MotionModel, class SensorModel>
 using AdaptiveMonteCarloLocalization2d = beluga::AdaptiveMonteCarloLocalization2d<
-    MotionDescriptor,
-    SensorDescriptor,
+    MotionModel,
+    SensorModel,
     beluga_ros::OccupancyGrid,
-    FilterUpdateControlInterface,
+    LaserLocalizationInterface2d,
     ConcreteResamplingPoliciesPoller>;
 
 /// Initializes particle filter states given pose `mean` and `covariance`.
diff --git a/beluga_amcl/src/amcl_node.cpp b/beluga_amcl/src/amcl_node.cpp
index 459c1d07b..7570cbd41 100644
--- a/beluga_amcl/src/amcl_node.cpp
+++ b/beluga_amcl/src/amcl_node.cpp
@@ -683,13 +683,6 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNode::make_particle_filter(
   auto selective_resampling_params = SelectiveResamplingPolicyParam{};
   selective_resampling_params.enabled = get_parameter("selective_resampling").as_bool();
 
-  using Stationary = beluga::mixin::descriptor<beluga::StationaryModel>;
-  using DifferentialDrive =
-      beluga::mixin::descriptor<beluga::DifferentialDriveModel, beluga::DifferentialDriveModelParam>;
-  using OmnidirectionalDrive =
-      beluga::mixin::descriptor<beluga::OmnidirectionalDriveModel, beluga::OmnidirectionalDriveModelParam>;
-
-  using MotionDescriptor = std::variant<Stationary, DifferentialDrive, OmnidirectionalDrive>;
   auto get_motion_descriptor = [this](std::string_view name) -> MotionDescriptor {
     if (name == kDifferentialModelName || name == kNav2DifferentialModelName) {
       auto params = beluga::DifferentialDriveModelParam{};
@@ -697,7 +690,7 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNode::make_particle_filter(
       params.rotation_noise_from_translation = get_parameter("alpha2").as_double();
       params.translation_noise_from_translation = get_parameter("alpha3").as_double();
       params.translation_noise_from_rotation = get_parameter("alpha4").as_double();
-      return DifferentialDrive{params};
+      return beluga::DifferentialDriveModel{params};
     }
     if (name == kOmnidirectionalModelName || name == kNav2OmnidirectionalModelName) {
       auto params = beluga::OmnidirectionalDriveModelParam{};
@@ -706,23 +699,15 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNode::make_particle_filter(
       params.translation_noise_from_translation = get_parameter("alpha3").as_double();
       params.translation_noise_from_rotation = get_parameter("alpha4").as_double();
       params.strafe_noise_from_translation = get_parameter("alpha5").as_double();
-      return OmnidirectionalDrive{params};
+      return beluga::OmnidirectionalDriveModel{params};
     }
     if (name == kStationaryModelName) {
-      return Stationary{};
+      return beluga::StationaryModel{};
     }
     throw std::invalid_argument(std::string("Invalid motion model: ") + std::string(name));
   };
 
-  using LikelihoodField = beluga::mixin::descriptor<
-      ciabatta::curry<beluga::LikelihoodFieldModel, beluga_ros::OccupancyGrid>::mixin,
-      beluga::LikelihoodFieldModelParam>;
-
-  using BeamSensorModel = beluga::mixin::descriptor<
-      ciabatta::curry<beluga::BeamSensorModel, beluga_ros::OccupancyGrid>::mixin, beluga::BeamModelParam>;
-
-  using SensorDescriptor = std::variant<LikelihoodField, BeamSensorModel>;
-  auto get_sensor_descriptor = [this](std::string_view name) -> SensorDescriptor {
+  auto get_sensor_descriptor = [this, map](std::string_view name) -> SensorDescriptor {
     if (name == kLikelihoodFieldModelName) {
       auto params = beluga::LikelihoodFieldModelParam{};
       params.max_obstacle_distance = get_parameter("laser_likelihood_max_dist").as_double();
@@ -730,7 +715,7 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNode::make_particle_filter(
       params.z_hit = get_parameter("z_hit").as_double();
       params.z_random = get_parameter("z_rand").as_double();
       params.sigma_hit = get_parameter("sigma_hit").as_double();
-      return LikelihoodField{params};
+      return beluga::LikelihoodFieldModel{params, beluga_ros::OccupancyGrid{map}};
     }
     if (name == kBeamSensorModelName) {
       auto params = beluga::BeamModelParam{};
@@ -741,17 +726,27 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNode::make_particle_filter(
       params.sigma_hit = get_parameter("sigma_hit").as_double();
       params.lambda_short = get_parameter("lambda_short").as_double();
       params.beam_max_range = get_parameter("laser_max_range").as_double();
-      return BeamSensorModel{params};
+      return beluga::BeamSensorModel{params, beluga_ros::OccupancyGrid{map}};
     }
     throw std::invalid_argument(std::string("Invalid sensor model: ") + std::string(name));
   };
 
   try {
-    using beluga::mixin::make_mixin;
-    return make_mixin<LaserLocalizationInterface2d, AdaptiveMonteCarloLocalization2d>(
-        sampler_params, limiter_params, get_motion_descriptor(get_parameter("robot_model_type").as_string()),
-        get_sensor_descriptor(get_parameter("laser_model_type").as_string()), beluga_ros::OccupancyGrid{map},
-        resample_on_motion_params, resample_interval_params, selective_resampling_params);
+    return std::visit(
+        [&](auto motion_model, auto sensor_model) -> std::unique_ptr<LaserLocalizationInterface2d> {
+          using MotionModel = decltype(motion_model);
+          using SensorModel = decltype(sensor_model);
+          return std::make_unique<AdaptiveMonteCarloLocalization2d<MotionModel, SensorModel>>(
+              sampler_params,             //
+              limiter_params,             //
+              motion_model,               //
+              sensor_model,               //
+              resample_on_motion_params,  //
+              resample_interval_params,   //
+              selective_resampling_params);
+        },
+        get_motion_descriptor(get_parameter("robot_model_type").as_string()),
+        get_sensor_descriptor(get_parameter("laser_model_type").as_string()));
   } catch (const std::invalid_argument& error) {
     RCLCPP_ERROR(get_logger(), "Coudn't instantiate the particle filter: %s", error.what());
   }
diff --git a/beluga_amcl/src/amcl_nodelet.cpp b/beluga_amcl/src/amcl_nodelet.cpp
index 46ddc0f1d..3e108c17d 100644
--- a/beluga_amcl/src/amcl_nodelet.cpp
+++ b/beluga_amcl/src/amcl_nodelet.cpp
@@ -201,7 +201,7 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNodelet::make_particle_filter(
       params.rotation_noise_from_translation = config_.odom_alpha2;
       params.translation_noise_from_translation = config_.odom_alpha3;
       params.translation_noise_from_rotation = config_.odom_alpha4;
-      return DifferentialDrive{params};
+      return beluga::DifferentialDriveModel{params};
     }
     if (name == kOmnidirectionalModelName || name == kAMCLOmnidirectionalModelName) {
       auto params = beluga::OmnidirectionalDriveModelParam{};
@@ -210,15 +210,15 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNodelet::make_particle_filter(
       params.translation_noise_from_translation = config_.odom_alpha3;
       params.translation_noise_from_rotation = config_.odom_alpha4;
       params.strafe_noise_from_translation = config_.odom_alpha5;
-      return OmnidirectionalDrive{params};
+      return beluga::OmnidirectionalDriveModel{params};
     }
     if (name == kStationaryModelName) {
-      return Stationary{};
+      return beluga::StationaryModel{};
     }
     throw std::invalid_argument(std::string("Invalid motion model: ") + std::string(name));
   };
 
-  auto get_sensor_descriptor = [this](std::string_view name) -> SensorDescriptor {
+  auto get_sensor_descriptor = [this, map](std::string_view name) -> SensorDescriptor {
     if (name == kLikelihoodFieldModelName) {
       auto params = beluga::LikelihoodFieldModelParam{};
       params.max_obstacle_distance = config_.laser_likelihood_max_dist;
@@ -226,7 +226,7 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNodelet::make_particle_filter(
       params.z_hit = config_.laser_z_hit;
       params.z_random = config_.laser_z_rand;
       params.sigma_hit = config_.laser_sigma_hit;
-      return LikelihoodField{params};
+      return beluga::LikelihoodFieldModel{params, beluga_ros::OccupancyGrid{map}};
     }
     if (name == kBeamSensorModelName) {
       auto params = beluga::BeamModelParam{};
@@ -237,17 +237,26 @@ std::unique_ptr<LaserLocalizationInterface2d> AmclNodelet::make_particle_filter(
       params.sigma_hit = config_.laser_sigma_hit;
       params.lambda_short = config_.laser_lambda_short;
       params.beam_max_range = config_.laser_max_range;
-      return BeamSensorModel{params};
+      return beluga::BeamSensorModel{params, beluga_ros::OccupancyGrid{map}};
     }
     throw std::invalid_argument(std::string("Invalid sensor model: ") + std::string(name));
   };
 
   try {
-    using beluga::mixin::make_mixin;
-    return make_mixin<LaserLocalizationInterface2d, AdaptiveMonteCarloLocalization2d>(
-        sampler_params, limiter_params, get_motion_descriptor(config_.odom_model_type),
-        get_sensor_descriptor(config_.laser_model_type), beluga_ros::OccupancyGrid{map}, resample_on_motion_params,
-        resample_interval_params, selective_resampling_params);
+    return std::visit(
+        [&](auto motion_model, auto sensor_model) -> std::unique_ptr<LaserLocalizationInterface2d> {
+          using MotionModel = decltype(motion_model);
+          using SensorModel = decltype(sensor_model);
+          return std::make_unique<AdaptiveMonteCarloLocalization2d<MotionModel, SensorModel>>(
+              sampler_params,             //
+              limiter_params,             //
+              motion_model,               //
+              sensor_model,               //
+              resample_on_motion_params,  //
+              resample_interval_params,   //
+              selective_resampling_params);
+        },
+        get_motion_descriptor(config_.odom_model_type), get_sensor_descriptor(config_.laser_model_type));
   } catch (const std::invalid_argument& error) {
     NODELET_ERROR("Could not instantiate the particle filter: %s", error.what());
   }
diff --git a/beluga_system_tests/test/test_system.cpp b/beluga_system_tests/test/test_system.cpp
index 9576b9f66..3ae6609bb 100644
--- a/beluga_system_tests/test/test_system.cpp
+++ b/beluga_system_tests/test/test_system.cpp
@@ -58,20 +58,20 @@ using ConcreteResamplingPoliciesPoller = beluga_amcl::FilterUpdateControlMixin<
     beluga_amcl::ResampleIntervalPolicy,
     beluga_amcl::SelectiveResamplingPolicy>;
 
-template <class MotionDescriptor, class SensorDescriptor>
+template <class MotionModel, class SensorModel>
 using AdaptiveMonteCarloLocalization2d = beluga::AdaptiveMonteCarloLocalization2d<
-    MotionDescriptor,
-    SensorDescriptor,
+    MotionModel,
+    SensorModel,
     beluga_ros::OccupancyGrid,
-    beluga_amcl::FilterUpdateControlInterface,
+    LaserLocalizationInterface2d,
     ConcreteResamplingPoliciesPoller>;
 
-template <class MotionDescriptor, class SensorDescriptor>
+template <class MotionModel, class SensorModel>
 using MonteCarloLocalization2d = beluga::MonteCarloLocalization2d<
-    MotionDescriptor,
-    SensorDescriptor,
+    MotionModel,
+    SensorModel,
     beluga_ros::OccupancyGrid,
-    beluga_amcl::FilterUpdateControlInterface,
+    LaserLocalizationInterface2d,
     ConcreteResamplingPoliciesPoller>;
 
 using beluga::MultivariateNormalDistribution;
@@ -296,15 +296,14 @@ std::unique_ptr<LaserLocalizationInterface2d> amcl_pf_from_map(nav_msgs::msg::Oc
   auto selective_resampling_params = beluga_amcl::SelectiveResamplingPolicyParam{};
   selective_resampling_params.enabled = false;
 
-  using DifferentialDrive =
-      beluga::mixin::descriptor<beluga::DifferentialDriveModel, beluga::DifferentialDriveModelParam>;
-  using LikelihoodField = beluga::mixin::descriptor<
-      ciabatta::curry<beluga::LikelihoodFieldModel, beluga_ros::OccupancyGrid>::mixin,
-      beluga::LikelihoodFieldModelParam>;
-
-  return beluga::mixin::make_mixin<LaserLocalizationInterface2d, AdaptiveMonteCarloLocalization2d>(
-      sampler_params, limiter_params, DifferentialDrive{motion_params}, LikelihoodField{sensor_params},
-      beluga_ros::OccupancyGrid{std::move(map)}, resample_on_motion_params, resample_interval_params,
+  return std::make_unique<AdaptiveMonteCarloLocalization2d<
+      beluga::DifferentialDriveModel, beluga::LikelihoodFieldModel<beluga_ros::OccupancyGrid>>>(
+      sampler_params,                                                                          //
+      limiter_params,                                                                          //
+      beluga::DifferentialDriveModel{motion_params},                                           //
+      beluga::LikelihoodFieldModel{sensor_params, beluga_ros::OccupancyGrid{std::move(map)}},  //
+      resample_on_motion_params,                                                               //
+      resample_interval_params,                                                                //
       selective_resampling_params);
 }
 
@@ -335,15 +334,13 @@ std::unique_ptr<LaserLocalizationInterface2d> likelihood_mcl_pf_from_map(nav_msg
   auto selective_resampling_params = beluga_amcl::SelectiveResamplingPolicyParam{};
   selective_resampling_params.enabled = false;
 
-  using DifferentialDrive =
-      beluga::mixin::descriptor<beluga::DifferentialDriveModel, beluga::DifferentialDriveModelParam>;
-  using LikelihoodField = beluga::mixin::descriptor<
-      ciabatta::curry<beluga::LikelihoodFieldModel, beluga_ros::OccupancyGrid>::mixin,
-      beluga::LikelihoodFieldModelParam>;
-
-  return beluga::mixin::make_mixin<LaserLocalizationInterface2d, MonteCarloLocalization2d>(
-      limiter_params, DifferentialDrive{motion_params}, LikelihoodField{sensor_params},
-      beluga_ros::OccupancyGrid{std::move(map)}, resample_on_motion_params, resample_interval_params,
+  return std::make_unique<MonteCarloLocalization2d<
+      beluga::DifferentialDriveModel, beluga::LikelihoodFieldModel<beluga_ros::OccupancyGrid>>>(
+      limiter_params,                                                                          //
+      beluga::DifferentialDriveModel{motion_params},                                           //
+      beluga::LikelihoodFieldModel{sensor_params, beluga_ros::OccupancyGrid{std::move(map)}},  //
+      resample_on_motion_params,                                                               //
+      resample_interval_params,                                                                //
       selective_resampling_params);
 }
 
@@ -370,14 +367,13 @@ std::unique_ptr<LaserLocalizationInterface2d> beam_mcl_pf_from_map(nav_msgs::msg
   auto selective_resampling_params = beluga_amcl::SelectiveResamplingPolicyParam{};
   selective_resampling_params.enabled = false;
 
-  using DifferentialDrive =
-      beluga::mixin::descriptor<beluga::DifferentialDriveModel, beluga::DifferentialDriveModelParam>;
-  using BeamSensorModel = beluga::mixin::descriptor<
-      ciabatta::curry<beluga::BeamSensorModel, beluga_ros::OccupancyGrid>::mixin, beluga::BeamModelParam>;
-
-  return beluga::mixin::make_mixin<LaserLocalizationInterface2d, MonteCarloLocalization2d>(
-      limiter_params, DifferentialDrive{motion_params}, BeamSensorModel{sensor_params},
-      beluga_ros::OccupancyGrid{std::move(map)}, resample_on_motion_params, resample_interval_params,
+  return std::make_unique<
+      MonteCarloLocalization2d<beluga::DifferentialDriveModel, beluga::BeamSensorModel<beluga_ros::OccupancyGrid>>>(
+      limiter_params,                                                                     //
+      beluga::DifferentialDriveModel{motion_params},                                      //
+      beluga::BeamSensorModel{sensor_params, beluga_ros::OccupancyGrid{std::move(map)}},  //
+      resample_on_motion_params,                                                          //
+      resample_interval_params,                                                           //
       selective_resampling_params);
 }