diff --git a/include/etl/private/variant_variadic.h b/include/etl/private/variant_variadic.h
index f45be48b..73cf5cbc 100644
--- a/include/etl/private/variant_variadic.h
+++ b/include/etl/private/variant_variadic.h
@@ -283,6 +283,75 @@ namespace etl
       }
     };
 
+    //****************************************************************************************************
+    /// Helpers for selecting the best conversion candidate for variant value construction.
+    /// Only implicit conversions that do not involve narrowing are considered.
+    //****************************************************************************************************
+    // Used to check for valid conversion that don't include narrowing as array copy-list-initialization excludes narrowing conversions.
+    template <typename T>
+    struct conversion_array
+    {
+      T value[1];
+    };
+
+    // Create a candidate function accepting TAlternative provided it can be constructed from T without narrowing conversions. When the conversion
+    // is valid, the function returns an integral constant representing the index of the alternative type in the variant's type list.
+    template <typename T, size_t Index, typename TAlternative, typename = void>
+    struct conversion_candidate
+    {
+      static void select();
+    };
+
+    template <typename T, size_t Index, typename TAlternative>
+    struct conversion_candidate<T, Index, TAlternative, etl::void_t<decltype(conversion_array<TAlternative>{{etl::declval<T>()}})> >
+    {
+      static etl::integral_constant<size_t, Index> select(TAlternative);
+    };
+
+    // Build all conversion overloads for a given type T across the list of alternative types.
+    template <typename T, size_t Index, typename... TTypes>
+    struct conversion_overloads_impl;
+
+    template <typename T, size_t Index>
+    struct conversion_overloads_impl<T, Index>
+    {
+      static void select();
+    };
+
+    template <typename T, size_t Index, typename THead, typename... TRest>
+    struct conversion_overloads_impl<T, Index, THead, TRest...>
+      : conversion_candidate<T, Index, THead>
+      , conversion_overloads_impl<T, Index + 1U, TRest...>
+    {
+      using conversion_candidate<T, Index, THead>::select;
+      using conversion_overloads_impl<T, Index + 1U, TRest...>::select;
+    };
+
+    template <typename T, typename... TTypes>
+    using conversion_overloads = conversion_overloads_impl<T, 0U, TTypes...>;
+
+    // Select the best alternative type for a given type T.
+    template <typename T, typename... TTypes>
+    using select_alternative_index = decltype(conversion_overloads<T, TTypes...>::select(etl::declval<T>()));
+
+    //*************************************************************************
+    /// Helpers for identifying in-place tags.
+    //*************************************************************************
+    template <typename T>
+    struct is_in_place_tag : etl::false_type
+    {
+    };
+
+    template <typename T>
+    struct is_in_place_tag<etl::in_place_type_t<T> > : etl::true_type
+    {
+    };
+
+    template <size_t Index>
+    struct is_in_place_tag<etl::in_place_index_t<Index> > : etl::true_type
+    {
+    };
+
     //*******************************************
     /// Constexpr get by index from variadic_union.
     //*******************************************
@@ -1016,22 +1085,26 @@ namespace etl
     /// Construct from a value.
     //***************************************************************************
   #include "diagnostic_uninitialized_push.h"
-    template <
-      typename T, bool Trivial_ = Is_Trivially_Destructible_Suite,
-      etl::enable_if_t<!etl::is_same<etl::remove_cvref_t<T>, variant>::value && !Trivial_ && etl::is_one_of<etl::remove_cvref_t<T>, TTypes...>::value,
-                       int> = 0>
+    template < typename T, bool Trivial_ = Is_Trivially_Destructible_Suite,
+               etl::enable_if_t< !etl::is_same<etl::remove_cvref_t<T>, variant>::value && !Trivial_
+                                   && !private_variant::is_in_place_tag<etl::remove_cvref_t<T> >::value,
+                                 int>  = 0,
+               size_t AlternativeIndex = private_variant::select_alternative_index<T, TTypes...>::value,
+               typename TAlternative = type_from_index<AlternativeIndex>, etl::enable_if_t<etl::is_constructible<TAlternative, T>::value, int> = 0>
     ETL_CONSTEXPR14 variant(T&& value)
-      : base_type(index_of_type<T>::value)
+      : base_type(AlternativeIndex)
     {
-      construct_in_place<etl::remove_cvref_t<T> >(data, etl::forward<T>(value));
+      construct_in_place<TAlternative>(data, etl::forward<T>(value));
     }
 
-    template <
-      typename T, bool Trivial_ = Is_Trivially_Destructible_Suite,
-      etl::enable_if_t<!etl::is_same<etl::remove_cvref_t<T>, variant>::value && Trivial_ && etl::is_one_of<etl::remove_cvref_t<T>, TTypes...>::value,
-                       int> = 0>
+    template < typename T, bool Trivial_ = Is_Trivially_Destructible_Suite,
+               etl::enable_if_t<!etl::is_same<etl::remove_cvref_t<T>, variant>::value && Trivial_
+                                  && !private_variant::is_in_place_tag<etl::remove_cvref_t<T> >::value,
+                                int>   = 0,
+               size_t AlternativeIndex = private_variant::select_alternative_index<T, TTypes...>::value,
+               typename TAlternative = type_from_index<AlternativeIndex>, etl::enable_if_t<etl::is_constructible<TAlternative, T>::value, int> = 0 >
     constexpr variant(T&& value)
-      : base_type(etl::in_place_index_t<index_of_type<T>::value>{}, etl::forward<T>(value), index_of_type<T>::value)
+      : base_type(etl::in_place_index_t<AlternativeIndex>{}, etl::forward<T>(value), AlternativeIndex)
     {
     }
   #include "diagnostic_pop.h"
@@ -1208,17 +1281,15 @@ namespace etl
     /// Move assignment operator for type.
     ///\param value The value to assign.
     //***************************************************************************
-    template <
-      typename T,
-      etl::enable_if_t<!etl::is_same<etl::remove_cvref_t<T>, variant>::value && etl::is_one_of<etl::remove_cvref_t<T>, TTypes...>::value, int> = 0>
+    template < typename T, etl::enable_if_t<!etl::is_same<etl::remove_cvref_t<T>, variant>::value, int> = 0,
+               size_t AlternativeIndex = private_variant::select_alternative_index<T, TTypes...>::value,
+               typename TAlternative = type_from_index<AlternativeIndex>, etl::enable_if_t<etl::is_constructible<TAlternative, T>::value, int> = 0>
     variant& operator=(T&& value)
     {
-      using type = etl::remove_cvref_t<T>;
-
       do_destroy();
-      do_construct<type>(etl::forward<T>(value));
+      do_construct<TAlternative>(etl::forward<T>(value));
 
-      type_id = index_of_type<type>::value;
+      type_id = AlternativeIndex;
 
       return *this;
     }
diff --git a/test/test_variant_variadic.cpp b/test/test_variant_variadic.cpp
index de09ff68..b7e69adb 100644
--- a/test/test_variant_variadic.cpp
+++ b/test/test_variant_variadic.cpp
@@ -831,7 +831,7 @@ namespace
     }
 
     //*************************************************************************
-    TEST(test_constructor_value)
+    TEST(test_constructor_value_no_conversion)
     {
       // Char.
       char               c = 'a';
@@ -855,6 +855,101 @@ namespace
       CHECK_EQUAL(text, etl::get<std::string>(variant_text_etl));
     }
 
+    //*************************************************************************
+    TEST(test_constructor_value_conversion)
+    {
+      // Non-narrowing numeric conversions should be allowed.
+      etl::variant<int, double> variant_double_trivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<double>(variant_double_trivial), true);
+      CHECK_EQUAL(1.5, etl::get<double>(variant_double_trivial));
+
+      etl::variant<std::string, double> variant_double_nontrivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<double>(variant_double_nontrivial), true);
+      CHECK_EQUAL(1.5, etl::get<double>(variant_double_nontrivial));
+
+      // Implicit conversions for non-numeric types should also be allowed.
+      struct ImplicitInt
+      {
+        operator int() const
+        {
+          return 42;
+        }
+      };
+
+      etl::variant<int, double> variant_implicit_int_trivial{ImplicitInt{}};
+      CHECK_EQUAL(etl::holds_alternative<int>(variant_implicit_int_trivial), true);
+      CHECK_EQUAL(42, etl::get<int>(variant_implicit_int_trivial));
+
+      etl::variant<int, std::string> variant_implicit_int_nontrivial{ImplicitInt{}};
+      CHECK_EQUAL(etl::holds_alternative<int>(variant_implicit_int_nontrivial), true);
+      CHECK_EQUAL(42, etl::get<int>(variant_implicit_int_nontrivial));
+
+      // Exact match should be chosen over other conversions.
+      etl::variant<int, double, float> variant_float_trivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<float>(variant_float_trivial), true);
+      CHECK_EQUAL(1.5f, etl::get<float>(variant_float_trivial));
+
+      etl::variant<std::string, double, float> variant_float_nontrivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<float>(variant_float_nontrivial), true);
+      CHECK_EQUAL(1.5f, etl::get<float>(variant_float_nontrivial));
+
+      // Conversion should be possible even in the presence of duplicate alternatives.
+      etl::variant<int, int, double> variant_duplicate_trivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<double>(variant_duplicate_trivial), true);
+      CHECK_EQUAL(1.5, etl::get<double>(variant_duplicate_trivial));
+
+      etl::variant<std::string, std::string, double> variant_duplicate_nontrivial{1.5f};
+      CHECK_EQUAL(etl::holds_alternative<double>(variant_duplicate_nontrivial), true);
+      CHECK_EQUAL(1.5, etl::get<double>(variant_duplicate_nontrivial));
+
+      // Narrowing conversion should not be allowed.
+      CHECK(!(etl::is_constructible<etl::variant<float>, double>::value));
+      CHECK(!(etl::is_constructible<etl::variant<std::string, float>, double>::value));
+      CHECK(!(std::is_constructible<etl::variant<int>, float>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, int>, float>::value));
+      CHECK(!(std::is_constructible<etl::variant<short>, int>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, short>, int>::value));
+      CHECK(!(std::is_constructible<etl::variant<unsigned int>, int>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, unsigned int>, int>::value));
+
+      // Construction should not be allowed when no implicit conversion is possible.
+      struct ExplicitInt
+      {
+        explicit operator int() const
+        {
+          return 42;
+        }
+      };
+
+      CHECK(!(std::is_constructible<etl::variant<bool>, const int*>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, bool>, const int*>::value));
+      CHECK(!(std::is_constructible<etl::variant<int>, ExplicitInt>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, int>, ExplicitInt>::value));
+
+      // Construction should not be allowed when the conversion is ambiguous.
+      struct AmbiguousIntLong
+      {
+        operator int() const
+        {
+          return 1;
+        }
+
+        operator long() const
+        {
+          return 1L;
+        }
+      };
+
+      CHECK(!(std::is_constructible<etl::variant<int, long>, AmbiguousIntLong>::value));
+      CHECK(!(std::is_constructible<etl::variant<std::string, int, long>, AmbiguousIntLong>::value));
+
+      // The converting constructor should not accept in-place type or index tags.
+      CHECK((!std::is_constructible<etl::variant<etl::in_place_type_t<int>>, etl::in_place_type_t<int>>::value));
+      CHECK((!std::is_constructible<etl::variant<std::string, etl::in_place_type_t<int>>, etl::in_place_type_t<int>>::value));
+      CHECK((!std::is_constructible<etl::variant<etl::in_place_index_t<1U>>, etl::in_place_index_t<1U>>::value));
+      CHECK((!std::is_constructible<etl::variant<std::string, etl::in_place_index_t<2U>>, etl::in_place_index_t<2U>>::value));
+    }
+
     //*************************************************************************
     TEST(test_constructor_move_value)
     {
@@ -1535,12 +1630,19 @@ namespace
     //*************************************************************************
     TEST(test_assign_from_value)
     {
+      // No conversion required
       std::string        text("Some Text");
       test_variant_etl_3 variant_etl;
 
       variant_etl = text;
 
       CHECK_EQUAL(text, etl::get<std::string>(variant_etl));
+
+      // Conversion from float to double required
+      etl::variant<int, double> variant_double;
+      variant_double = 1.5f;
+
+      CHECK_EQUAL(1.5, etl::get<double>(variant_double));
     }
 
     //*************************************************************************