diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..127a5bc
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..088a300
--- /dev/null
+++ b/README.md
@@ -0,0 +1,22 @@
+# strict variant
+
+This library was adapted from [cbeck88/strict-variant](https://github.com/cbeck88/strict-variant) to compile to Arduino/ESP32 platform.
+
+Documentation
+=============
+
+On [Chris Beck's github pages](https://cbeck88.github.io/strict-variant/index.html).
+
+Compiler Compatibility
+======================
+
+`strict_variant` targets the C++11 standard.
+
+It is known to work with `gcc >= 4.8` and `clang >= 3.5`, and is tested against `MSVC 2015`.
+
+`strict_variant` can be used as-is in projects which require `-fno-exceptions` and `-fno-rtti`.
+
+Licensing and Distribution
+==========================
+
+**strict variant** is available under the boost software license.
\ No newline at end of file
diff --git a/examples/StrictVariantBasic/main.cpp b/examples/StrictVariantBasic/main.cpp
new file mode 100644
index 0000000..ff74696
--- /dev/null
+++ b/examples/StrictVariantBasic/main.cpp
@@ -0,0 +1,56 @@
+#include <Arduino.h>
+#include "strict_variant/variant.hpp"
+
+using namespace strict_variant;
+
+std::string getString(variant<int, std::string> v);
+int getInt(variant<int, std::string> v);
+void printParams(std::vector<variant<int, std::string>> params);
+
+void setup()
+{
+    Serial.begin(115200);
+
+    printf("Starting ...");
+
+    std::vector<variant<int, std::string>> params;
+
+	variant<int, std::string> param1;
+	param1 = "1031001";
+
+	variant<int, std::string> param2;
+	param2 = 60;
+	
+	params.push_back(param1);
+	params.push_back(param2);
+	
+	printParams(params);
+
+    while (1);
+}
+
+void loop()
+{
+}
+
+void printParams(std::vector<variant<int, std::string>> params)
+{
+    printf("Printing parameters...\n");
+
+    variant<int, std::string> param1 = params[0];
+    printf("Param1: %s\n", getString(param1).c_str());
+
+    variant<int, std::string> vlimCurva;
+    vlimCurva = params[1];
+    printf("Param2: %d\n", getInt(vlimCurva));
+}
+
+int getInt(variant<int, std::string> v)
+{
+    return *(get<int>(&v));
+}
+
+std::string getString(variant<int, std::string> v)
+{
+    return *(get<std::string>(&v));
+}
\ No newline at end of file
diff --git a/library.json b/library.json
new file mode 100644
index 0000000..ed133b6
--- /dev/null
+++ b/library.json
@@ -0,0 +1,23 @@
+{
+  "name": "strict_variant",
+  "version": "1.0.0",
+  "description": "A realtime/embedded-friendly C++11 variant type which is never empty and prevents undesirable implicit conversions.",
+  "keywords": "variant, polymorphism, container, cpp11, type-safety, union",
+  "authors":
+  [
+    {
+      "name":  "Vinicius de Sá",
+      "url":   "https://github.com/xvinny",
+      "maintainer": true
+    }
+  ],
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/xvinny/strict_variant.git"
+  },
+  "homepage": "https://github.com/xvinny/strict_variant",
+  "frameworks": [ "arduino" ],
+  "platforms": "*",
+  "examples": "examples/*/*.cpp"
+}
\ No newline at end of file
diff --git a/library.properties b/library.properties
new file mode 100644
index 0000000..556b4d1
--- /dev/null
+++ b/library.properties
@@ -0,0 +1,9 @@
+name=strict_variant
+version=1.0.0
+author=Vinicius de Sá
+maintainer=Vinicius de Sá
+sentence=A realtime/embedded-friendly C++11 variant type which is never empty and prevents undesirable implicit conversions
+paragraph=Includes an example for Arduino.
+category=Other
+url=https://github.com/xvinny/strict_variant
+architectures=*
\ No newline at end of file
diff --git a/src/strict_variant/alloc_variant.hpp b/src/strict_variant/alloc_variant.hpp
new file mode 100644
index 0000000..6782ac2
--- /dev/null
+++ b/src/strict_variant/alloc_variant.hpp
@@ -0,0 +1,36 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/alloc_wrapper.hpp>
+#include <strict_variant/mpl/std_traits.hpp>
+#include <strict_variant/variant.hpp>
+#include <type_traits>
+
+namespace strict_variant {
+
+//[ strict_variant_alloc_variant
+template <template <typename> class Alloc>
+struct alloc_variant {
+
+  // Version of wrap_if_throwing_move which uses alloc_wrapper<_, Alloc>
+
+  template <typename T, typename = mpl::enable_if_t<std::is_nothrow_destructible<T>::value
+                                                    && !std::is_reference<T>::value>>
+  struct wrap_throwing_move {
+    using type = typename std::conditional<std::is_nothrow_move_constructible<T>::value, T,
+                                           alloc_wrapper<T, Alloc<T>>>::type;
+  };
+
+  template <typename T>
+  using wrap_throwing_move_t = typename wrap_throwing_move<T>::type;
+
+  template <typename... Ts>
+  using type = variant<wrap_throwing_move_t<Ts>...>;
+};
+//]
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/alloc_wrapper.hpp b/src/strict_variant/alloc_wrapper.hpp
new file mode 100644
index 0000000..e6bdbe0
--- /dev/null
+++ b/src/strict_variant/alloc_wrapper.hpp
@@ -0,0 +1,137 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/***
+ * For use with strict_variant::variant
+ */
+#include <strict_variant/wrapper.hpp>
+#include <type_traits>
+#include <utility>
+
+// #define STRICT_VARIANT_DEBUG
+
+#ifdef STRICT_VARIANT_DEBUG
+#include <cassert>
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+    assert((X) && C);                                                                              \
+  } while (0)
+
+#else // STRICT_VARIANT_DEBUG
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+  } while (0)
+
+#endif // STRICT_VARIANT_DEBUG
+
+//[ strict_variant_alloc_wrapper
+namespace strict_variant {
+
+template <typename T, typename Alloc>
+class alloc_wrapper {
+  T * m_t;
+
+  void destroy() {
+    if (m_t) {
+      Alloc a;
+      m_t->~T();
+      a.deallocate(m_t, 1);
+    }
+  }
+
+  // To avoid doing explicit try / catch (since some projects use -fno-exceptions),
+  // use a function object to do initialization, which cleans up after itself in the dtor
+  // if initialization was unsuccessful.
+
+  struct initer {
+    Alloc a;
+    bool success;
+    T * m_t;
+
+    initer()
+      : a()
+      , success(false)
+      , m_t(nullptr) {
+      m_t = a.allocate(1);
+    }
+
+    ~initer() {
+      if (!success) { a.deallocate(m_t, 1); }
+    }
+
+    template <typename... Args>
+    void go(Args &&... args) {
+      new (m_t) T(std::forward<Args>(args)...);
+      success = true;
+    }
+  };
+
+  template <typename... Args>
+  void init(Args &&... args) {
+    initer i;
+    i.go(std::forward<Args>(args)...);
+    m_t = i.m_t;
+  }
+
+public:
+  typedef T value_type;
+
+  ~alloc_wrapper() noexcept { this->destroy(); }
+
+  template <typename... Args>
+  alloc_wrapper(Args &&... args)
+    : m_t(nullptr) {
+    this->init(std::forward<Args>(args)...);
+  }
+
+  alloc_wrapper(alloc_wrapper & rhs)
+    : alloc_wrapper(static_cast<const alloc_wrapper &>(rhs)) {}
+
+  alloc_wrapper(const alloc_wrapper & rhs)
+    : m_t(nullptr) {
+    this->init(rhs.get());
+  }
+
+  // Pointer move
+  alloc_wrapper(alloc_wrapper && rhs) noexcept //
+    : m_t(rhs.m_t)                             //
+  {
+    rhs.m_t = nullptr;
+  }
+
+  // Not assignable, we never actually need this, and it adds complexity
+  // associated to lifetime of `m_t` object.
+  alloc_wrapper & operator=(const alloc_wrapper &) = delete;
+  alloc_wrapper & operator=(alloc_wrapper &&) = delete;
+
+  T & get() & {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return *m_t;
+  }
+  const T & get() const & {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return *m_t;
+  }
+  T && get() && {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return std::move(*m_t);
+  }
+};
+//]
+
+namespace detail {
+
+template <typename T, typename A>
+struct is_wrapper<alloc_wrapper<T, A>> : std::true_type {};
+
+} // end namespace detail
+
+} // end namespace strict_variant
+
+#undef STRICT_VARIANT_ASSERT
diff --git a/src/strict_variant/conversion_rank.hpp b/src/strict_variant/conversion_rank.hpp
new file mode 100644
index 0000000..85b30c0
--- /dev/null
+++ b/src/strict_variant/conversion_rank.hpp
@@ -0,0 +1,95 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/***
+ * Some metafunctions that support safely_constructible type_trait
+ *
+ * Permits to classify all fundamental arithmetic types
+     integral, character, wide_char, bool, floating point
+ *
+ * and assign numeric ranks to them which are *portable*.
+ *
+ * These ranks should be the same on any standards-conforming implementation of
+ * C++, if not, it is a bug in this header.
+ */
+
+#include <type_traits>
+
+//[ strict_variant_arithmetic_category
+namespace strict_variant {
+namespace mpl {
+
+enum class arithmetic_category : char { integer, character, wide_char, boolean, floating };
+
+template <typename T, typename ENABLE = void>
+struct classify_arithmetic;
+
+} // end namespace mpl
+} // end namespace strict_variant
+//]
+
+namespace strict_variant {
+namespace mpl {
+
+template <typename T>
+struct classify_arithmetic<T, typename std::enable_if<std::is_integral<T>::value>::type> {
+  static constexpr arithmetic_category value = arithmetic_category::integer;
+};
+
+#define CLASSIFY(T, C)                                                                             \
+  template <>                                                                                      \
+  struct classify_arithmetic<T, void> {                                                            \
+    static constexpr arithmetic_category value = arithmetic_category::C;                           \
+  }
+
+CLASSIFY(char, character);
+CLASSIFY(signed char, character);
+CLASSIFY(unsigned char, character);
+CLASSIFY(char16_t, character);
+CLASSIFY(char32_t, character);
+CLASSIFY(wchar_t, wide_char);
+CLASSIFY(bool, boolean);
+CLASSIFY(float, floating);
+CLASSIFY(double, floating);
+CLASSIFY(long double, floating);
+
+#undef CLASSIFY
+
+template <typename T>
+struct arithmetic_rank;
+
+#define RANK(T, V)                                                                                 \
+  template <>                                                                                      \
+  struct arithmetic_rank<T> {                                                                      \
+    static constexpr int value = V;                                                                \
+  }
+
+#define URANK(T, V)                                                                                \
+  RANK(T, V);                                                                                      \
+  RANK(unsigned T, V)
+
+RANK(bool, 0);
+
+RANK(signed char, 0);
+RANK(char, 0);
+RANK(unsigned char, 0);
+RANK(char16_t, 1);
+RANK(char32_t, 2);
+
+URANK(short, 0);
+URANK(int, 1);
+URANK(long, 2);
+URANK(long long, 3);
+
+RANK(float, 0);
+RANK(double, 1);
+RANK(long double, 2);
+
+#undef RANK
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/filter_overloads.hpp b/src/strict_variant/filter_overloads.hpp
new file mode 100644
index 0000000..7185662
--- /dev/null
+++ b/src/strict_variant/filter_overloads.hpp
@@ -0,0 +1,72 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/conversion_rank.hpp>
+#include <strict_variant/mpl/find_any_in_list.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+#include <strict_variant/mpl/ulist.hpp>
+#include <strict_variant/recursive_wrapper.hpp>
+#include <strict_variant/safely_constructible.hpp>
+
+namespace strict_variant {
+
+// Dominates is a condition that we use to eliminate overloads in some cases.
+// If C is the argument, and A and B are in an overload set, and C is safely
+// convertible to A and to B, and A dominates B, then B will be removed.
+// Dominates should be thought of as a predicate on A and B, but is allowed to
+// be sensitive to the identity of C.
+//[ strict_variant_dominates_trait
+template <typename A, typename B, typename C, typename ENABLE = void>
+struct dominates : std::false_type {};
+
+template <typename A, typename B, typename C>
+struct dominates<A, B, C,
+                 mpl::enable_if_t<decay_to_arithmetic<A>::value && decay_to_arithmetic<B>::value
+                                  && decay_to_arithmetic<C>::value
+                                  && !safely_constructible<A, B>::value
+                                  && safely_constructible<B, A>::value>> : std::true_type {};
+//]
+
+// filter_overloads implements filtering rules for in variant(T&&) ctor
+template <typename T, typename TL>
+struct filter_overloads;
+
+template <typename T, typename... Ts>
+struct filter_overloads<T, mpl::TypeList<Ts...>> {
+  using unwrapped_types = mpl::TypeList<unwrap_type_t<Ts>...>;
+
+  template <unsigned u>
+  struct get_t {
+    using type = mpl::Index_At<unwrapped_types, u>;
+  };
+
+  template <unsigned u>
+  struct safe_prop : safely_constructible<typename get_t<u>::type, T> {};
+
+  using safe_pool = mpl::ulist_filter_t<safe_prop, mpl::count_t<sizeof...(Ts)>>;
+
+  using safe_types = mpl::ulist_map_t<get_t, safe_pool>;
+
+  template <typename U>
+  struct dominating {
+    template <typename V>
+    struct prop : dominates<V, U, T> {};
+  };
+
+  template <unsigned u>
+  struct undominated {
+    static constexpr bool value =
+      !mpl::Find_Any_In_List<dominating<typename get_t<u>::type>::template prop, safe_types>::value;
+  };
+
+  using safe_and_undominated = mpl::ulist_filter_t<undominated, safe_pool>;
+
+  // result
+  using type = safe_and_undominated;
+};
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/find_any_in_list.hpp b/src/strict_variant/mpl/find_any_in_list.hpp
new file mode 100644
index 0000000..ea087b6
--- /dev/null
+++ b/src/strict_variant/mpl/find_any_in_list.hpp
@@ -0,0 +1,22 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/find_with.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+
+namespace strict_variant {
+namespace mpl {
+
+// A version of find_any for a typelist rather than a parameter pack
+template <template <class> class P, typename TL>
+struct Find_Any_In_List;
+
+template <template <class> class P, typename... Ts>
+struct Find_Any_In_List<P, mpl::TypeList<Ts...>> : Find_Any<P, Ts...> {};
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/find_with.hpp b/src/strict_variant/mpl/find_with.hpp
new file mode 100644
index 0000000..9446711
--- /dev/null
+++ b/src/strict_variant/mpl/find_with.hpp
@@ -0,0 +1,62 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <cstddef> // for std::size_t
+
+namespace strict_variant {
+namespace mpl {
+
+/***
+ * Some random template metafunction utilities, originally for variant
+ */
+
+// helper any_has, check a (boolean) property against a list. returns index of
+// found item, or,
+// sizeof + 1
+template <template <typename> class Property, typename...>
+struct Find_With;
+
+template <template <typename> class Property>
+struct Find_With<Property> {
+  static constexpr std::size_t value = 1;
+};
+
+template <template <typename> class Property, typename T, typename... Types>
+struct Find_With<Property, T, Types...> {
+  static constexpr std::size_t value =
+    (Property<T>::value ? 0 : (1 + Find_With<Property, Types...>::value));
+};
+
+// find_any
+template <template <typename> class Property, typename... Ts>
+struct Find_Any {
+  static constexpr bool value = Find_With<Property, Ts...>::value < sizeof...(Ts);
+};
+
+// Negate_Property
+template <template <typename> class Property>
+struct Negate_Property {
+  template <typename T>
+  struct prop {
+    static constexpr bool value = !Property<T>::value;
+  };
+};
+
+// None_Have
+template <template <typename> class Property, typename... Ts>
+struct None_Have {
+  static constexpr bool value = !Find_Any<Property, Ts...>::value;
+};
+
+// All_Have
+template <template <typename> class Property, typename... Ts>
+struct All_Have {
+  static constexpr bool value = !Find_Any<Negate_Property<Property>::template prop, Ts...>::value;
+};
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/max.hpp b/src/strict_variant/mpl/max.hpp
new file mode 100644
index 0000000..599653d
--- /dev/null
+++ b/src/strict_variant/mpl/max.hpp
@@ -0,0 +1,56 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <type_traits>
+
+namespace strict_variant {
+namespace detail {
+
+/***
+ * Self contained implementation of 'std::max' of a predicate over a list of
+ * arguments
+ * by Jarryd Beck
+ */
+template <template <typename> class Size, typename SoFar, typename... Args>
+struct max_helper;
+
+template <template <typename> class Size, typename SoFar>
+struct max_helper<Size, SoFar> {
+  static constexpr decltype(Size<SoFar>::value) value = Size<SoFar>::value;
+  typedef SoFar type;
+};
+
+template <template <typename> class Size, typename SoFar, typename Next, typename... Args>
+struct max_helper<Size, SoFar, Next, Args...> {
+private:
+  typedef typename std::conditional<(Size<Next>::value > Size<SoFar>::value),
+                                    max_helper<Size, Next, Args...>,
+                                    max_helper<Size, SoFar, Args...>>::type m_next;
+
+public:
+  static constexpr decltype(Size<SoFar>::value) value = m_next::value;
+
+  typedef typename m_next::type type;
+};
+} // end namespace detail
+
+namespace mpl {
+template <template <typename> class Size, typename... Args>
+struct max;
+
+template <template <typename> class Size, typename First, typename... Args>
+struct max<Size, First, Args...> {
+private:
+  typedef decltype(Size<First>::value) m_size_type;
+  typedef detail::max_helper<Size, First, Args...> m_helper;
+
+public:
+  static constexpr m_size_type value = m_helper::value;
+  typedef typename m_helper::type type;
+};
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/nonstd_traits.hpp b/src/strict_variant/mpl/nonstd_traits.hpp
new file mode 100644
index 0000000..73c7885
--- /dev/null
+++ b/src/strict_variant/mpl/nonstd_traits.hpp
@@ -0,0 +1,87 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+/***
+ * Some traits that aren't standard but are kind of close
+ */
+
+namespace strict_variant {
+namespace mpl {
+
+// Modified version of std::common_type
+
+// Support: Need a std::decay which allows l-value references to pass through
+template <class T>
+using mini_decay_t = typename std::conditional<std::is_lvalue_reference<T>::value, T,
+                                               typename std::decay<T>::type>::type;
+
+// Our version of common_type uses mini_decay instead of decay
+template <typename T, typename... Ts>
+struct common_return_type;
+
+template <typename T>
+struct common_return_type<T> {
+  using type = mini_decay_t<T>;
+};
+
+template <typename T1, typename T2>
+struct common_return_type<T1, T2> {
+  using type = mini_decay_t<decltype(true ? std::declval<T1>() : std::declval<T2>())>;
+};
+
+template <typename T1, typename T2, typename T3, typename... Ts>
+struct common_return_type<T1, T2, T3, Ts...> {
+  using type =
+    typename common_return_type<typename common_return_type<T1, T2>::type, T3, Ts...>::type;
+};
+
+template <typename T, typename... Ts>
+using common_return_type_t = typename common_return_type<T, Ts...>::type;
+
+// is_nothrow_swappable
+
+namespace adl_swap_ns {
+
+using std::swap;
+
+// TODO: Fix on MSVC
+// error C2660: 'std::swap': function does not take 1 arguments
+#ifndef _MSC_VER
+
+/***
+ * is_nothrow_swappable
+ *   This implementation is stolen from WG proposal 0185
+ *   http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0185r1.html#Appendix
+ */
+struct do_is_nothrow_swappable {
+  template <class T>
+  static auto test(int)
+    -> std::integral_constant<bool, noexcept(swap(std::declval<T &>(), std::declval<T &>()))>;
+
+  template <class>
+  static std::false_type test(...);
+};
+
+template <typename T>
+struct is_nothrow_swappable : decltype(do_is_nothrow_swappable::test<T>(0)) {};
+
+#else
+
+template <typename T>
+struct is_nothrow_swappable : std::false_type {};
+
+#endif
+
+} // end namespace adl_swap_ns
+
+using adl_swap_ns::is_nothrow_swappable;
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/std_traits.hpp b/src/strict_variant/mpl/std_traits.hpp
new file mode 100644
index 0000000..c9b76b8
--- /dev/null
+++ b/src/strict_variant/mpl/std_traits.hpp
@@ -0,0 +1,30 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/***
+ * Some C++14 traits that are backported
+ */
+
+#include <type_traits>
+
+namespace strict_variant {
+namespace mpl {
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool b, typename U = void>
+using enable_if_t = typename std::enable_if<b, U>::type;
+
+} // end namespace mpl
+} // end namsepace strict_variant
diff --git a/src/strict_variant/mpl/tuple_cdr.hpp b/src/strict_variant/mpl/tuple_cdr.hpp
new file mode 100644
index 0000000..bea48f1
--- /dev/null
+++ b/src/strict_variant/mpl/tuple_cdr.hpp
@@ -0,0 +1,48 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/ulist.hpp>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace strict_variant {
+namespace mpl {
+
+// We need a tuple_cdr
+// Impl courtesy of Johnathan Wakely
+// http://stackoverflow.com/questions/14852593/removing-the-first-type-of-a-stdtuple
+// Changed a few things though :)
+
+template <typename T, typename Seq>
+struct tuple_cdr_impl;
+
+template <typename T, unsigned I0, unsigned... I>
+struct tuple_cdr_impl<T, ulist<I0, I...>> {
+  using type = std::tuple<typename std::tuple_element<I, T>::type...>;
+};
+
+template <typename T>
+struct tuple_cdr : tuple_cdr_impl<T, count_t<std::tuple_size<T>::value>> {};
+
+// Actual impl
+template <typename T, unsigned I0, unsigned... I>
+typename tuple_cdr<typename std::remove_reference<T>::type>::type
+cdr_impl(T && t, ulist<I0, I...>) {
+  return typename tuple_cdr<typename std::remove_reference<T>::type>::type{std::get<I>(t)...};
+}
+
+template <typename T>
+typename tuple_cdr<typename std::remove_reference<T>::type>::type
+cdr_tuple(T && t) {
+  return cdr_impl(std::forward<T>(t),
+                  count_t<std::tuple_size<typename std::remove_reference<T>::type>::value>{});
+}
+
+} // end namespace mpl
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/typelist.hpp b/src/strict_variant/mpl/typelist.hpp
new file mode 100644
index 0000000..c92f591
--- /dev/null
+++ b/src/strict_variant/mpl/typelist.hpp
@@ -0,0 +1,132 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <type_traits>
+
+namespace strict_variant {
+namespace mpl {
+
+// Poor man's boost::mpl::vector.
+template <class... Ts>
+struct TypeList {
+  static constexpr int size = sizeof...(Ts);
+};
+
+template <class List, class T>
+struct Append;
+
+template <class... Ts, class T>
+struct Append<TypeList<Ts...>, T> {
+  typedef TypeList<Ts..., T> type;
+};
+
+/***
+ * Some metafunctions for working with typelists
+ */
+
+// Metafunction Concat: Concatenate two typelists
+template <typename L, typename R>
+struct Concat;
+
+template <typename... TL, typename... TR>
+struct Concat<TypeList<TL...>, TypeList<TR...>> {
+  typedef TypeList<TL..., TR...> type;
+};
+
+template <typename L, typename R>
+using Concat_t = typename Concat<L, R>::type;
+
+// Metafunction Split: Split a typelist at a particular index
+template <int i, typename TL>
+struct Split;
+
+template <int k, typename... TL>
+struct Split<k, TypeList<TL...>> {
+private:
+  typedef Split<k / 2, TypeList<TL...>> FirstSplit;
+  typedef Split<k - k / 2, typename FirstSplit::R> SecondSplit;
+
+public:
+  typedef Concat_t<typename FirstSplit::L, typename SecondSplit::L> L;
+  typedef typename SecondSplit::R R;
+};
+
+template <typename T, typename... TL>
+struct Split<0, TypeList<T, TL...>> {
+  typedef TypeList<> L;
+  typedef TypeList<T, TL...> R;
+};
+
+template <typename T, typename... TL>
+struct Split<1, TypeList<T, TL...>> {
+  typedef TypeList<T> L;
+  typedef TypeList<TL...> R;
+};
+
+template <int k>
+struct Split<k, TypeList<>> {
+  typedef TypeList<> L;
+  typedef TypeList<> R;
+};
+
+// Metafunction Subdivide: Split a typelist into two roughly equal typelists
+template <typename TL>
+struct Subdivide : Split<TL::size / 2, TL> {};
+
+/***
+ * Index_At metafunction
+ * Based this on Subdivide, in order to reduce recursion depth
+ */
+template <typename T, std::size_t i, typename Enable = void>
+struct Index_At_s;
+
+// Prevent out of bounds
+template <typename T>
+struct Index_At_s<TypeList<T>, 0> {
+  using type = T;
+};
+
+template <typename TL, std::size_t i>
+struct Index_At_s<TL, i, typename std::enable_if<(TL::size >= 2 && i < TL::size / 2)>::type> {
+  using type = typename Index_At_s<typename Subdivide<TL>::L, i>::type;
+};
+
+template <typename TL, std::size_t i>
+struct Index_At_s<TL, i, typename std::enable_if<(TL::size >= 2 && TL::size / 2 <= i
+                                                  && i < TL::size)>::type> {
+  using type = typename Index_At_s<typename Subdivide<TL>::R, i - (TL::size / 2)>::type;
+};
+
+template <typename T, std::size_t i>
+using Index_At = typename Index_At_s<T, i>::type;
+
+/***
+ * Back_Of metafunction
+ */
+template <typename T>
+struct Back_Of_s;
+
+template <typename T, typename... Ts>
+struct Back_Of_s<TypeList<T, Ts...>> : Index_At<TypeList<T, Ts...>, sizeof...(Ts)> {};
+
+template <typename T>
+using Back_Of = Back_Of_s<T>;
+
+/***
+ * typelist_fwd metafunction
+ * Pass the members of a typelist to a variadic template
+ */
+template <template <class...> class, typename TL>
+struct typelist_fwd;
+
+template <template <class...> class F, typename... Ts>
+struct typelist_fwd<F, TypeList<Ts...>> {
+  using type = F<Ts...>;
+};
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/mpl/ulist.hpp b/src/strict_variant/mpl/ulist.hpp
new file mode 100644
index 0000000..b907333
--- /dev/null
+++ b/src/strict_variant/mpl/ulist.hpp
@@ -0,0 +1,86 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <cstddef>
+#include <strict_variant/mpl/typelist.hpp>
+
+namespace strict_variant {
+namespace mpl {
+
+template <unsigned... us>
+struct ulist {
+  static constexpr std::size_t size = sizeof...(us);
+};
+
+// Concat
+
+template <unsigned... ul, unsigned... ur>
+struct Concat<ulist<ul...>, ulist<ur...>> {
+  typedef ulist<ul..., ur...> type;
+};
+
+// Append
+template <typename UL, unsigned u>
+struct append;
+
+template <unsigned u, unsigned... us>
+struct append<ulist<us...>, u> {
+  using type = ulist<us..., u>;
+};
+
+template <typename UL, unsigned u>
+using append_t = typename append<UL, u>::type;
+
+// Count function
+template <std::size_t n>
+struct count {
+  using type = append_t<typename count<n - 1>::type, n - 1>;
+};
+
+template <>
+struct count<0> {
+  using type = ulist<>;
+};
+
+template <std::size_t n>
+using count_t = typename count<n>::type;
+
+// map function
+template <template <unsigned> class F, typename TL>
+struct ulist_map;
+
+template <template <unsigned> class F, unsigned... us>
+struct ulist_map<F, ulist<us...>> {
+  using type = mpl::TypeList<typename F<us>::type...>;
+};
+
+template <template <unsigned> class F, typename TL>
+using ulist_map_t = typename ulist_map<F, TL>::type;
+
+// filter function
+
+template <template <unsigned> class F, typename UL>
+struct ulist_filter;
+
+template <template <unsigned> class F>
+struct ulist_filter<F, ulist<>> {
+  using type = ulist<>;
+};
+
+template <template <unsigned> class F, unsigned u, unsigned... us>
+struct ulist_filter<F, ulist<u, us...>> {
+  using recurse_t = typename ulist_filter<F, ulist<us...>>::type;
+
+  using type =
+    typename std::conditional<F<u>::value, Concat_t<ulist<u>, recurse_t>, recurse_t>::type;
+};
+
+template <template <unsigned> class F, typename UL>
+using ulist_filter_t = typename ulist_filter<F, UL>::type;
+
+} // end namespace mpl
+} // end namespace strict_variant
diff --git a/src/strict_variant/multivisit.hpp b/src/strict_variant/multivisit.hpp
new file mode 100644
index 0000000..5d0eec3
--- /dev/null
+++ b/src/strict_variant/multivisit.hpp
@@ -0,0 +1,151 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/tuple_cdr.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+#include <strict_variant/mpl/ulist.hpp>
+#include <strict_variant/variant.hpp>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace strict_variant {
+namespace mpl {
+
+template <typename Visitor, typename... Args, unsigned... us>
+auto
+eval_visitor_impl(Visitor && vis, std::tuple<Args...> && tup, mpl::ulist<us...>) -> decltype(
+  std::forward<Visitor>(std::declval<Visitor>())(std::forward<Args>(std::declval<Args>())...)) {
+  return std::forward<Visitor>(vis)(std::forward<Args>(std::get<us>(tup))...);
+}
+
+// Tracks the state of how many things we have visited
+
+template <typename Visitor, typename VisitedList, typename UnvisitedList>
+struct multivisitor_state_base;
+
+template <typename Visitor, typename... Vs, typename... Us>
+struct multivisitor_state_base<Visitor, TypeList<Vs...>, TypeList<Us...>> {
+  Visitor vis_;
+  std::tuple<Vs...> vs_;
+  std::tuple<Us...> us_;
+
+  explicit multivisitor_state_base(Visitor vis, std::tuple<Vs...> vs, std::tuple<Us...> us)
+    : vis_(std::forward<Visitor>(vis))
+    , vs_(std::move(vs))
+    , us_(std::move(us)) {}
+};
+
+// Primary template for multivisitor_state
+template <typename Visitor, typename VisitedList, typename UnvisitedList>
+struct multivisitor_state;
+
+// When there is nothing left to visit then actually apply the visitor
+// Need to use eval_visitor_impl to actually get the index sequence passed forward
+template <typename Visitor, typename... Vs>
+struct multivisitor_state<Visitor, TypeList<Vs...>, TypeList<>>
+  : multivisitor_state_base<Visitor, TypeList<Vs...>, TypeList<>> {
+
+  using base_t = multivisitor_state_base<Visitor, TypeList<Vs...>, TypeList<>>;
+
+  // Ctor
+  explicit multivisitor_state(Visitor vis, std::tuple<Vs...> vs, std::tuple<> us)
+    : base_t(std::forward<Visitor>(vis), std::move(vs), std::move(us)) {}
+
+  // Members
+  using base_t::vis_;
+  using base_t::vs_;
+  using base_t::us_;
+
+  decltype(std::forward<Visitor>(std::declval<Visitor>())(std::forward<Vs>(std::declval<Vs>())...))
+  evaluate() {
+    return eval_visitor_impl(std::forward<Visitor>(vis_), std::move(vs_),
+                             mpl::count_t<sizeof...(Vs)>{});
+  }
+};
+
+// Inductive hypothesis
+// Clang really wants the functor to be a complete type at the time that we are evaluating
+// "evaluate", so these need
+// to be two separate types even if its more convoluted.
+template <typename Visitor, typename VL, typename UL>
+struct multivisitor_state_functor;
+
+template <typename Visitor, typename... Vs, typename U1, typename... Us>
+struct multivisitor_state_functor<Visitor, TypeList<Vs...>, TypeList<U1, Us...>>
+  : multivisitor_state_base<Visitor, TypeList<Vs...>, TypeList<U1, Us...>> {
+
+  using base_t = multivisitor_state_base<Visitor, TypeList<Vs...>, TypeList<U1, Us...>>;
+
+  // Ctor
+  explicit multivisitor_state_functor(Visitor vis, std::tuple<Vs...> vs, std::tuple<U1, Us...> us)
+    : base_t(std::forward<Visitor>(vis), std::move(vs), std::move(us)) {}
+
+  // Members
+  using base_t::vis_;
+  using base_t::vs_;
+  using base_t::us_;
+
+  template <typename T>
+  using next_state_t = multivisitor_state<Visitor, TypeList<Vs..., T>, TypeList<Us...>>;
+
+  // Update the state, by moving a value to the visited list and popping from Unvisited
+  template <typename T>
+  auto operator()(T && t) -> decltype(std::declval<next_state_t<T>>().evaluate()) {
+    next_state_t<T> new_state{std::forward<Visitor>(vis_),
+                              std::tuple_cat(vs_, std::tuple<T>{std::forward<T>(t)}),
+                              mpl::cdr_tuple(us_)};
+    return new_state.evaluate();
+  }
+};
+
+template <typename Visitor, typename... Vs, typename U1, typename... Us>
+struct multivisitor_state<Visitor, TypeList<Vs...>, TypeList<U1, Us...>>
+  : multivisitor_state_functor<Visitor, TypeList<Vs...>, TypeList<U1, Us...>> {
+
+  using functor_t = multivisitor_state_functor<Visitor, TypeList<Vs...>, TypeList<U1, Us...>>;
+
+  // Ctor
+  explicit multivisitor_state(Visitor vis, std::tuple<Vs...> vs, std::tuple<U1, Us...> us)
+    : functor_t(std::forward<Visitor>(vis), std::move(vs), std::move(us)) {}
+
+  using functor_t::us_;
+
+  auto evaluate() -> decltype(apply_visitor(*static_cast<functor_t *>(nullptr),
+                                            std::forward<U1>(std::declval<U1>()))) {
+    return apply_visitor(*this, std::forward<U1>(std::get<0>(us_)));
+  }
+};
+
+} // end namespace mpl
+
+namespace detail {
+
+template <typename Visitor, typename... Us>
+auto
+multivisit_impl(Visitor && visitor, Us &&... us) -> decltype(
+  static_cast<mpl::multivisitor_state<Visitor, mpl::TypeList<>, mpl::TypeList<Us...>> *>(nullptr)
+    ->evaluate()) {
+  mpl::multivisitor_state<Visitor, mpl::TypeList<>, mpl::TypeList<Us...>> st{
+    std::forward<Visitor>(visitor), {}, std::tuple<Us...>{std::forward<Us>(us)...}};
+  return st.evaluate();
+}
+
+} // end namespace detail
+
+template <typename Visitor, typename V1, typename V2, typename... Vs>
+auto
+apply_visitor(Visitor && vis, V1 && v1, V2 && v2, Vs &&... vs)
+  -> decltype(detail::multivisit_impl(std::forward<Visitor>(std::declval<Visitor>()),
+                                      std::forward<V1>(std::declval<V1>()),
+                                      std::forward<V2>(std::declval<V2>()),
+                                      std::forward<Vs>(std::declval<Vs>())...)) {
+  return detail::multivisit_impl(std::forward<Visitor>(vis), std::forward<V1>(v1),
+                                 std::forward<V2>(v2), std::forward<Vs>(vs)...);
+}
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/recursive_wrapper.hpp b/src/strict_variant/recursive_wrapper.hpp
new file mode 100644
index 0000000..d57a45f
--- /dev/null
+++ b/src/strict_variant/recursive_wrapper.hpp
@@ -0,0 +1,104 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/***
+ * For use with strict_variant::variant
+ */
+#include <new>
+#include <strict_variant/variant_fwd.hpp>
+#include <strict_variant/wrapper.hpp>
+#include <type_traits>
+#include <utility>
+
+// #define STRICT_VARIANT_DEBUG
+
+#ifdef STRICT_VARIANT_DEBUG
+#include <cassert>
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+    assert((X) && C);                                                                              \
+  } while (0)
+
+#else // STRICT_VARIANT_DEBUG
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+  } while (0)
+
+#endif // STRICT_VARIANT_DEBUG
+
+//[ strict_variant_recursive_wrapper
+namespace strict_variant {
+
+template <typename T>
+class recursive_wrapper {
+  T * m_t;
+
+  void destroy() { delete m_t; }
+
+  template <typename... Args>
+  void init(Args &&... args) {
+    m_t = new T(std::forward<Args>(args)...);
+  }
+
+public:
+  typedef T value_type;
+
+  ~recursive_wrapper() noexcept { this->destroy(); }
+
+  template <typename... Args>
+  recursive_wrapper(Args &&... args)
+    : m_t(nullptr) {
+    this->init(std::forward<Args>(args)...);
+  }
+
+  recursive_wrapper(recursive_wrapper & rhs)
+    : recursive_wrapper(static_cast<const recursive_wrapper &>(rhs)) {}
+
+  recursive_wrapper(const recursive_wrapper & rhs)
+    : m_t(nullptr) {
+    this->init(rhs.get());
+  }
+
+  // Pointer move
+  recursive_wrapper(recursive_wrapper && rhs) noexcept //
+    : m_t(rhs.m_t)                                     //
+  {
+    rhs.m_t = nullptr;
+  }
+
+  // Not assignable, we never actually need this, and it adds complexity
+  // associated to lifetime of `m_t` object.
+  recursive_wrapper & operator=(const recursive_wrapper &) = delete;
+  recursive_wrapper & operator=(recursive_wrapper &&) = delete;
+
+  T & get() & {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return *m_t;
+  }
+  const T & get() const & {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return *m_t;
+  }
+  T && get() && {
+    STRICT_VARIANT_ASSERT(m_t, "Bad access!");
+    return std::move(*m_t);
+  }
+};
+//]
+
+namespace detail {
+
+template <typename T>
+struct is_wrapper<recursive_wrapper<T>> : std::true_type {};
+
+} // end namespace detail
+
+} // end namespace strict_variant
+
+#undef STRICT_VARIANT_ASSERT
diff --git a/src/strict_variant/safe_arithmetic_conversion.hpp b/src/strict_variant/safe_arithmetic_conversion.hpp
new file mode 100644
index 0000000..f26069a
--- /dev/null
+++ b/src/strict_variant/safe_arithmetic_conversion.hpp
@@ -0,0 +1,57 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/conversion_rank.hpp>
+#include <strict_variant/mpl/std_traits.hpp>
+#include <type_traits>
+
+namespace strict_variant {
+
+/***
+ * Metafunction `safe_arithmetic_conversion`
+ *
+ * Type relationship on two parameters, both should be arithmetic types.
+ *
+ * Identifies a subset of conversions which
+ * - Do not cross the "arithmetic categories" that we defined.
+ * - Are *totally portable*: No narrowing or implementation-defined behavior.
+ *
+ * This means:
+ *   - Arithmetic category must be the same
+ *   - Arithmetic rank must be nondecreasing
+ *   - Unsigned -> Signed is not allowed.
+ */
+
+//[ strict_variant_safe_arithmetic_conversion
+template <typename A, typename B>
+struct safe_arithmetic_conversion {
+  static constexpr bool same_class =
+    (mpl::classify_arithmetic<A>::value == mpl::classify_arithmetic<B>::value);
+  static constexpr bool unsign_to_sign = !std::is_unsigned<A>::value && std::is_unsigned<B>::value;
+  static constexpr bool narrowing =
+    (mpl::arithmetic_rank<A>::value < mpl::arithmetic_rank<B>::value);
+
+  static constexpr bool value = same_class && !unsign_to_sign && !narrowing;
+};
+
+template <typename A>
+struct safe_arithmetic_conversion<A, char> {
+  static constexpr bool value = safe_arithmetic_conversion<A, signed char>::value
+                                && safe_arithmetic_conversion<A, unsigned char>::value;
+};
+
+template <typename B>
+struct safe_arithmetic_conversion<char, B> {
+  static constexpr bool value = safe_arithmetic_conversion<signed char, B>::value
+                                && safe_arithmetic_conversion<unsigned char, B>::value;
+};
+
+template <>
+struct safe_arithmetic_conversion<char, char> : std::true_type {};
+//]
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/safe_pointer_conversion.hpp b/src/strict_variant/safe_pointer_conversion.hpp
new file mode 100644
index 0000000..91752ac
--- /dev/null
+++ b/src/strict_variant/safe_pointer_conversion.hpp
@@ -0,0 +1,32 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/std_traits.hpp>
+#include <type_traits>
+
+namespace strict_variant {
+
+/***
+ * Metafunction `safe_pointer_conversion`
+ *
+ * Type relationship on two parameters, both should be pointer types.
+ *
+ * Identifies a subset of conversions which are permitted during variant construction.
+ */
+
+//[ strict_variant_safe_pointer_conversion
+template <typename A, typename B>
+struct safe_pointer_conversion;
+
+template <typename A, typename B>
+struct safe_pointer_conversion<A *, B *> {
+  static constexpr bool value = (std::is_same<A, B>::value || std::is_same<A, const B>::value)
+                                && std::is_constructible<A *, B *>::value;
+};
+//]
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/safely_constructible.hpp b/src/strict_variant/safely_constructible.hpp
new file mode 100644
index 0000000..a62afc0
--- /dev/null
+++ b/src/strict_variant/safely_constructible.hpp
@@ -0,0 +1,60 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/conversion_rank.hpp>
+#include <strict_variant/mpl/std_traits.hpp>
+#include <strict_variant/safe_arithmetic_conversion.hpp>
+#include <strict_variant/safe_pointer_conversion.hpp>
+#include <type_traits>
+
+namespace strict_variant {
+
+/***
+ * Metafunction `safely_constructible`:
+ *   A metafunction yielding a bool which detects is A is constructible from B without using
+ *   conversions that we consider "unsafe".
+ *
+ *   The main purpose of this trait is to support `strict_variant::variant` in deciding what
+ *   conversions to allow, and how to deduce what internal type to assign to any given type.
+ */
+
+//[ strict_variant_safely_constructible
+// Helper metafunction which checks if type is arithmetic after decay.
+// This is the same as, `is_arithmetic` modulo `const` and references.
+template <typename T>
+struct decay_to_arithmetic : std::is_arithmetic<mpl::decay_t<T>> {};
+
+// Helper metafunction which checks if type is pointer after decay
+template <typename T>
+struct decay_to_ptr : std::is_pointer<mpl::decay_t<T>> {};
+
+// Primary template, falls back to std::is_constructible
+template <typename A, typename B, typename ENABLE = void>
+struct safely_constructible : std::is_constructible<A, B> {};
+
+// If both are arithmetic after decay, then pass to safe_arithmetic_conversion
+template <typename A, typename B>
+struct safely_constructible<A, B, mpl::enable_if_t<decay_to_arithmetic<A>::value
+                                                   && decay_to_arithmetic<B>::value>>
+  : safe_arithmetic_conversion<mpl::decay_t<A>, mpl::decay_t<B>> {};
+
+// If both are pointer after decay, then pass to safe_pointer_conversion
+template <typename A, typename B>
+struct safely_constructible<A, B,
+                            mpl::enable_if_t<decay_to_ptr<A>::value && decay_to_ptr<B>::value>>
+  : safe_pointer_conversion<mpl::decay_t<A>, mpl::decay_t<B>> {};
+
+// If one is arithmetic and the other is pointer, after decay, it is forbidden.
+template <typename A, typename B>
+struct safely_constructible<A, B, mpl::enable_if_t<(decay_to_arithmetic<A>::value
+                                                    && decay_to_ptr<B>::value)
+                                                   || (decay_to_ptr<A>::value
+                                                       && decay_to_arithmetic<B>::value)>>
+  : std::false_type {};
+//]
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/variant.hpp b/src/strict_variant/variant.hpp
new file mode 100644
index 0000000..fc7edfd
--- /dev/null
+++ b/src/strict_variant/variant.hpp
@@ -0,0 +1,882 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/**
+ * A modern C++ tagged-union variant class.
+ *
+ * This effectively has similar functionality and mostly the same interface as
+ * boost::variant, but replaces the implementation with C++11 features.
+ *
+ * Fully supports move semantics, and arbitrary numbers of types.
+ * A major advantage is the use of variadic templates instead of the
+ * boost mpl / boost macro library, which make compilation take a long
+ * time and can be hard to follow, at least for the uninitiated.
+ *
+ * This code is derived from (an early version of) Jarryd Beck's variant:
+ *   https://github.com/jarro2783/thenewcpp
+ */
+
+#include <strict_variant/filter_overloads.hpp>
+#include <strict_variant/mpl/find_with.hpp>
+#include <strict_variant/mpl/nonstd_traits.hpp>
+#include <strict_variant/mpl/std_traits.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+#include <strict_variant/mpl/ulist.hpp>
+#include <strict_variant/recursive_wrapper.hpp>
+#include <strict_variant/safely_constructible.hpp>
+#include <strict_variant/variant_detail.hpp>
+#include <strict_variant/variant_dispatch.hpp>
+#include <strict_variant/variant_fwd.hpp>
+#include <strict_variant/variant_storage.hpp>
+
+#include <type_traits>
+#include <utility>
+
+// #define STRICT_VARIANT_ASSUME_MOVE_NOTHROW
+// #define STRICT_VARIANT_ASSUME_COPY_NOTHROW
+// #define STRICT_VARIANT_DEBUG
+
+#ifdef STRICT_VARIANT_DEBUG
+#include <cassert>
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+    assert((X) && C);                                                                              \
+  } while (0)
+
+#else // STRICT_VARIANT_DEBUG
+
+#define STRICT_VARIANT_ASSERT(X, C)                                                                \
+  do {                                                                                             \
+  } while (0)
+
+#endif // STRICT_VARIANT_DEBUG
+
+namespace strict_variant {
+
+/***
+ * Trait to detect specializations of variant
+ */
+template <typename T>
+struct is_variant : std::false_type {};
+
+template <typename First, typename... Types>
+struct is_variant<variant<First, Types...>> : std::true_type {};
+
+/***
+ * Tag used in tag-dispatch with emplace-ctor
+ */
+template <typename T>
+struct emplace_tag {};
+
+/***
+ * Class variant
+ */
+template <typename First, typename... Types>
+class variant {
+
+private:
+  /***
+   * Check noexcept status of special member functions of our types
+   */
+  static_assert(mpl::All_Have<std::is_nothrow_destructible, First>::value,
+                "All types in this variant type must be nothrow destructible");
+  static_assert(mpl::All_Have<std::is_nothrow_destructible, Types...>::value,
+                "All types in this variant type must be nothrow destructible");
+
+  /***
+   * Prohibit references
+   */
+  static_assert(mpl::None_Have<std::is_reference, First>::value,
+                "Cannot store references in this variant, use `std::reference_wrapper`");
+  static_assert(mpl::None_Have<std::is_reference, Types...>::value,
+                "Cannot store references in this variant, use `std::reference_wrapper`");
+
+  /***
+   * Data members
+   */
+
+  using storage_t = detail::storage<First, Types...>;
+  storage_t m_storage;
+
+  int m_which;
+
+  /***
+   * Initialize and destroy
+   */
+  void destroy() noexcept {
+    destroyer d;
+    this->apply_visitor_internal(d);
+  }
+
+  template <std::size_t index, typename... Args>
+  void initialize(Args &&... args) noexcept(
+    noexcept(static_cast<storage_t *>(nullptr)->template initialize<index>(
+      std::forward<Args>(std::declval<Args>())...))) {
+    m_storage.template initialize<index>(std::forward<Args>(args)...);
+    this->m_which = static_cast<int>(index);
+  }
+
+  /***
+   * (Type-changing) Assignment
+   */
+  template <std::size_t index, typename Rhs>
+  void assign(Rhs && rhs) {
+    constexpr bool assume_nothrow_init =
+      std::is_lvalue_reference<Rhs>::value
+        ? detail::variant_noexcept_helper<First, Types...>::assume_copy_nothrow
+        : detail::variant_noexcept_helper<First, Types...>::assume_move_nothrow;
+
+    // This is a recursive_wrapper if that is what storage is using internally
+    using temp_t = typename storage_t::template value_t<index>;
+
+    // Three cases:
+    // 1) Already had an RHS type in the variant. Use assignment directly. Must pierce
+    // recursive_wrapper.
+    // 2) Must change type, but initializing the new value is noexcept. Can destroy and do it
+    // directly.
+    // 3) Must change type, and initializing the new value may throw. Do it on the stack, and then
+    // move into storage.
+
+    static_assert(noexcept(this->destroy()), "Noexcept assumption failed!");
+
+    if (this->which() == index) {
+      m_storage.template get_value<index>(detail::false_{}) = std::forward<Rhs>(rhs);
+    } else if (assume_nothrow_init || noexcept(this->initialize<index>(std::forward<Rhs>(rhs)))) {
+      this->destroy();
+      this->initialize<index>(std::forward<Rhs>(rhs));
+    } else {
+      static_assert(detail::variant_noexcept_helper<First, Types...>::assume_move_nothrow
+                      || noexcept(this->initialize<index>(std::declval<temp_t>())),
+                    "Noexcept assumption failed!");
+
+      temp_t tmp(std::forward<Rhs>(rhs));      // may throw
+      this->destroy();                         // nothrow
+      this->initialize<index>(std::move(tmp)); // nothrow
+    }
+  }
+
+  /***
+   * Used for internal visitors
+   */
+  template <typename Visitor>
+  auto apply_visitor_internal(Visitor & visitor) -> typename Visitor::result_type {
+    // Implementation note:
+    // `detail::true_` here indicates that the visit is internal and we should
+    // NOT pierce `recursive_wrapper`.
+    return detail::visitor_dispatch<detail::true_, 1 + sizeof...(Types)>{}(static_cast<unsigned>(m_which), m_storage,
+                                                                           visitor);
+  }
+
+  /***
+   * find_which is used with non-T&& ctors to figure out what "which" should be
+   * used for a given type
+   */
+  template <typename Rhs>
+  struct find_which {
+    static constexpr std::size_t value =
+      mpl::Find_With<detail::same_modulo_const_ref_wrapper<Rhs>::template prop, First,
+                     Types...>::value;
+    static_assert(value < (sizeof...(Types) + 1), "No match for value");
+  };
+
+  /***
+   * Visitors used to implement special member functions and such
+   */
+  struct constructor;
+  struct assigner;
+  struct destroyer;
+  struct swapper;
+
+  /***
+   * initializer_slot is a template function which figures out which slot
+   * should be used when initializing or assigning from an object of type T &&.
+   *
+   * This is used in T && ctor and T && operator =.
+   * It works by creating an appropriate overloaded function object and
+   * applying it to an argument of type T &&.
+   */
+
+  // init_helper trait maps an index to the corresponding value type, by
+  // interrogating storage_t to ensure consistency.
+  template <unsigned idx>
+  struct init_helper {
+    using type = unwrap_type_t<typename storage_t::template value_t<idx>>;
+  };
+
+  // Initializer leaf is a function object
+  // Note: Actually the "forbidding" is accomplished using filter_overloads
+  // below, we don't need to use SFINAE on operator() here.
+  template <typename T, unsigned idx>
+  struct initializer_leaf {
+    using target_type = typename init_helper<idx>::type;
+
+    constexpr std::integral_constant<unsigned, idx> operator()(target_type) const { return {}; }
+  };
+
+  // Main object, created using inheritance
+  // T should be a forwarding reference
+  template <typename T, typename UL>
+  struct initializer_base;
+
+  template <typename T, unsigned u>
+  struct initializer_base<T, mpl::ulist<u>> : initializer_leaf<T, u> {
+    using initializer_leaf<T, u>::operator();
+  };
+
+  template <typename T, unsigned u, unsigned... us>
+  struct initializer_base<T, mpl::ulist<u, us...>> : initializer_leaf<T, u>,
+                                                     initializer_base<T, mpl::ulist<us...>> {
+    using initializer_leaf<T, u>::operator();
+    using initializer_base<T, mpl::ulist<us...>>::operator();
+  };
+
+  template <typename T>
+  struct initializer
+    : initializer_base<T,
+                       typename filter_overloads<T, mpl::ulist_map_t<init_helper,
+                                                                     mpl::count_t<sizeof...(Types)
+                                                                                  + 1>>>::type> {};
+
+  // Interface, this is what is actually used in T && ctor and assignment op
+  template <typename T>
+  static constexpr unsigned initializer_slot() {
+    return decltype(initializer<T>{}(std::declval<T>()))::value;
+  }
+
+public:
+  ~variant() noexcept { this->destroy(); }
+
+  // Constructors
+  // Note: We use detail:: instead of std:: for trait because we handle
+  // recursive_wrapper<T> specially
+  // TODO: It would be nice if we actually SFINAED the definitions of these
+  // special member functions, following akrzemi1's technical description:
+  // https://akrzemi1.wordpress.com/2015/03/02/a-conditional-copy-constructor/
+  variant() noexcept(detail::is_nothrow_default_constructible<First>::value);
+
+  variant(const variant & rhs) noexcept(
+    detail::variant_noexcept_helper<First, Types...>::nothrow_copy_ctors);
+
+  variant(variant && rhs) noexcept(
+    detail::variant_noexcept_helper<First, Types...>::nothrow_move_ctors);
+
+  /// Forwarding-reference ctor, construct a variant from one of its value
+  /// types, using overload resolution. See documentation.
+  template <typename T,
+            typename =
+              mpl::enable_if_t<!is_variant<mpl::remove_const_t<mpl::remove_reference_t<T>>>::value>>
+  variant(T && t);
+
+  /// "Generalizing Ctor"
+  /// Allow constructing from a variant over a subset of our types
+  /// (Boost variant does this, and we need it to comfortably interact with
+  /// spirit)
+  template <typename OFirst, typename... OTypes,
+            typename Enable = mpl::enable_if_t<detail::proper_subvariant<variant<OFirst, OTypes...>,
+                                                                         variant>::value>>
+  variant(const variant<OFirst, OTypes...> & other) noexcept(
+    detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_copy_ctors);
+
+  /// "Generalizing" move ctor, similar as above
+  template <typename OFirst, typename... OTypes,
+            typename Enable = mpl::enable_if_t<detail::proper_subvariant<variant<OFirst, OTypes...>,
+                                                                         variant>::value>>
+  variant(variant<OFirst, OTypes...> && other) noexcept(
+    detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_move_ctors);
+
+  // Emplace ctor. Used to explicitly specify the type of the variant, and
+  // invoke an arbitrary ctor of that type.
+  template <typename T, typename... Args>
+  explicit variant(emplace_tag<T>,
+                   Args &&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value);
+
+  /***
+   * Modifiers
+   */
+
+  // Assignment
+  variant & operator=(const variant & rhs) noexcept(
+    detail::variant_noexcept_helper<First, Types...>::nothrow_copy_assign);
+
+  variant & operator=(variant && rhs) noexcept(
+    detail::variant_noexcept_helper<First, Types...>::nothrow_move_assign);
+
+  // Forwarding reference assignment
+  template <typename T,
+            typename =
+              mpl::enable_if_t<!is_variant<mpl::remove_const_t<mpl::remove_reference_t<T>>>::value>>
+  variant & operator=(T && t);
+
+  // Generalizing assignment
+  template <typename OFirst, typename... OTypes,
+            typename Enable = mpl::enable_if_t<detail::proper_subvariant<variant<OFirst, OTypes...>,
+                                                                         variant>::value>>
+  variant & operator=(const variant<OFirst, OTypes...> & other) noexcept(
+    detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_copy_assign);
+
+  template <typename OFirst, typename... OTypes,
+            typename Enable = mpl::enable_if_t<detail::proper_subvariant<variant<OFirst, OTypes...>,
+                                                                         variant>::value>>
+  variant & operator=(variant<OFirst, OTypes...> && other) noexcept(
+    detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_move_assign);
+
+  // Emplace operation
+  template <std::size_t index, typename... Args>
+  mpl::enable_if_t<!std::is_nothrow_constructible<typename storage_t::template value_t<index>,
+                                                  Args...>::value>
+  emplace(Args &&... args) noexcept(false);
+
+  template <std::size_t index, typename... Args>
+  mpl::enable_if_t<std::is_nothrow_constructible<typename storage_t::template value_t<index>,
+                                                 Args...>::value>
+  emplace(Args &&... args) noexcept;
+
+  // Emplace with explicitly specified type -- makes a call to index version
+  template <typename T, typename... Args>
+  void emplace(Args &&... args) noexcept(noexcept(
+    static_cast<variant *>(nullptr)->emplace<find_which<T>::value>(std::forward<Args>(args)...))) {
+    constexpr std::size_t idx = find_which<T>::value;
+    static_assert(idx < sizeof...(Types) + 1,
+                  "Requested type is not a member of this variant type");
+
+    this->emplace<idx>(std::forward<Args>(args)...);
+  }
+
+  // Swap operation
+  // Optimized in case of `recursive_wrapper` to use a pointer move.
+  void swap(variant & other) noexcept;
+
+  /***
+   * Accessors
+   */
+
+  int which() const noexcept { return m_which; }
+
+  // get
+  template <typename T>
+  T * get() noexcept {
+    constexpr std::size_t idx = find_which<T>::value;
+    static_assert(idx < sizeof...(Types) + 1,
+                  "Requested type is not a member of this variant type");
+
+    return this->get<idx>();
+  }
+
+  template <typename T>
+  const T * get() const noexcept {
+    constexpr std::size_t idx = find_which<T>::value;
+    static_assert(idx < sizeof...(Types) + 1,
+                  "Requested type is not a member of this variant type");
+
+    return this->get<idx>();
+  }
+
+  // get with integer index
+  template <std::size_t idx>
+  auto get() noexcept
+    -> decltype(&static_cast<storage_t *>(nullptr)->template get_value<idx>(detail::false_{})) {
+    if (idx == m_which) {
+      return &m_storage.template get_value<idx>(detail::false_{});
+    } else {
+      return nullptr;
+    }
+  }
+
+  template <std::size_t idx>
+  auto get() const noexcept -> decltype(
+    &static_cast<const storage_t *>(nullptr)->template get_value<idx>(detail::false_{})) {
+    if (idx == m_which) {
+      return &m_storage.template get_value<idx>(detail::false_{});
+    } else {
+      return nullptr;
+    }
+  }
+
+  /***
+   * Visitation
+   */
+
+  // Implementation details for apply_visitor
+  // private:
+  using dispatcher_t = detail::visitor_dispatch<detail::false_, 1 + sizeof...(Types)>;
+
+#define APPLY_VISITOR_IMPL_BODY                                                                    \
+  dispatcher_t{}(static_cast<unsigned>(visitable.which()), std::forward<Visitable>(visitable).m_storage,                  \
+                 std::forward<Visitor>(visitor))
+
+  // Visitable is assumed to be, forwarding reference to this type.
+  template <typename Visitor, typename Visitable>
+  static auto apply_visitor_impl(Visitor && visitor,
+                                 Visitable && visitable) noexcept(noexcept(APPLY_VISITOR_IMPL_BODY))
+    -> decltype(APPLY_VISITOR_IMPL_BODY) {
+    static_assert(std::is_same<const variant, const mpl::remove_reference_t<Visitable>>::value,
+                  "Misuse of apply_visitor_impl!");
+    return APPLY_VISITOR_IMPL_BODY;
+  }
+
+#undef APPLY_VISITOR_IMPL_BODY
+
+  // public:
+  // C++17 visit syntax
+  template <typename V>
+    auto visit(V && v)
+    & noexcept(noexcept(apply_visitor_impl(std::forward<V>(v), *static_cast<variant *>(nullptr))))
+        -> decltype(apply_visitor_impl(std::forward<V>(v), *this)) {
+    return apply_visitor_impl(std::forward<V>(v), *this);
+  }
+
+  template <typename V>
+  auto visit(V && v) const & noexcept(
+    noexcept(apply_visitor_impl(std::forward<V>(v), *static_cast<const variant *>(nullptr))))
+    -> decltype(apply_visitor_impl(std::forward<V>(v), *this)) {
+    return apply_visitor_impl(std::forward<V>(v), *this);
+  }
+
+  template <typename V>
+    auto visit(V && v)
+    && noexcept(noexcept(apply_visitor_impl(std::forward<V>(v),
+                                            std::move(*static_cast<variant *>(nullptr)))))
+         -> decltype(apply_visitor_impl(std::forward<V>(v), std::move(*this))) {
+    return apply_visitor_impl(std::forward<V>(v), std::move(*this));
+  }
+};
+
+/***
+ * apply one visitor function. `boost::variant` syntax.
+ * This is the basic version, used in implementation of multivisitation.
+ */
+#define APPLY_VISITOR_BODY                                                                         \
+  mpl::remove_reference_t<Visitable>::apply_visitor_impl(std::forward<Visitor>(visitor),           \
+                                                         std::forward<Visitable>(visitable))
+template <typename Visitor, typename Visitable>
+auto
+apply_visitor(Visitor && visitor, Visitable && visitable) noexcept(noexcept(APPLY_VISITOR_BODY))
+  -> decltype(APPLY_VISITOR_BODY) {
+  return APPLY_VISITOR_BODY;
+}
+
+#undef APPLY_VISITOR_BODY
+
+/***
+ * strict_variant::get function (same semantics as boost::get with pointer type)
+ */
+template <typename T, typename... Types>
+T *
+get(variant<Types...> * var) noexcept {
+  return var->template get<T>();
+}
+
+template <typename T, typename... Types>
+const T *
+get(const variant<Types...> * var) noexcept {
+  return var->template get<T>();
+}
+
+// Using integer index
+template <std::size_t idx, typename... Types>
+auto
+get(variant<Types...> * var) noexcept
+  -> decltype(static_cast<variant<Types...> *>(nullptr)->template get<idx>()) {
+  return var->template get<idx>();
+}
+
+template <std::size_t idx, typename... Types>
+auto
+get(const variant<Types...> * var) noexcept
+  -> decltype(static_cast<const variant<Types...> *>(nullptr)->template get<idx>()) {
+  return var->template get<idx>();
+}
+
+/// If a variant has type T, then get a reference to it,
+/// otherwise, create a new T default value in the variant
+/// and return a reference to the new value.
+template <typename T, typename... Types>
+T &
+get_or_default(variant<Types...> & v,
+               T def = {}) noexcept(std::is_nothrow_move_constructible<T>::value) {
+  T * t = strict_variant::get<T>(&v);
+  if (!t) {
+    v.template emplace<T>(std::move(def));
+    t = strict_variant::get<T>(&v);
+    STRICT_VARIANT_ASSERT(t, "Move assignment to a variant failed to change its type!");
+  }
+  return *t;
+}
+
+/***
+ * Trait to add the wrapper if a type is not no-throw move constructible
+ */
+
+//[ strict_variant_wrap_if_throwing_move
+template <typename T, typename = mpl::enable_if_t<std::is_nothrow_destructible<T>::value
+                                                  && !std::is_reference<T>::value>>
+struct wrap_if_throwing_move {
+  using type = typename std::conditional<std::is_nothrow_move_constructible<T>::value, T,
+                                         recursive_wrapper<T>>::type;
+};
+
+template <typename T>
+using wrap_if_throwing_move_t = typename wrap_if_throwing_move<T>::type;
+//]
+
+//[ strict_variant_easy_variant
+template <typename... Ts>
+using easy_variant = variant<wrap_if_throwing_move_t<Ts>...>;
+//]
+
+/***
+ * Implementation details of private visitors
+ */
+template <typename First, typename... Types>
+struct variant<First, Types...>::constructor {
+  typedef void result_type;
+
+  explicit constructor(variant & self)
+    : m_self(self) {}
+
+  template <typename T>
+  void operator()(T && rhs) const {
+    constexpr std::size_t index = find_which<mpl::remove_reference_t<T>>::value;
+    m_self.template initialize<index>(std::forward<T>(rhs));
+  }
+
+private:
+  variant & m_self;
+};
+
+// assigner
+template <typename First, typename... Types>
+struct variant<First, Types...>::assigner {
+
+  static_assert(detail::variant_noexcept_helper<First, Types...>::assignable,
+                "All types in this variant must be nothrow move constructible or placed in a "
+                "recursive_wrapper, or the variant cannot be assigned!");
+
+  explicit assigner(variant & self)
+    : m_self(self) {}
+
+  template <typename Rhs>
+  void operator()(Rhs && rhs) const {
+    constexpr std::size_t index = find_which<mpl::remove_reference_t<Rhs>>::value;
+    m_self.template assign<index>(std::forward<Rhs>(rhs));
+  }
+
+private:
+  variant & m_self;
+};
+
+// destroyer
+template <typename First, typename... Types>
+struct variant<First, Types...>::destroyer {
+  typedef void result_type;
+
+  template <typename T>
+  void operator()(T & t) const noexcept {
+    t.~T();
+  }
+};
+
+/***
+ * Implementation details of ctors
+ */
+
+#define STRICT_VARIANT_ASSERT_WHICH_INVARIANT                                                      \
+  STRICT_VARIANT_ASSERT(static_cast<unsigned>(this->which()) < sizeof...(Types) + 1,               \
+                        "Postcondition failed!")
+
+template <typename First, typename... Types>
+variant<First, Types...>::variant() noexcept(
+  detail::is_nothrow_default_constructible<First>::value) {
+  static_assert(std::is_default_constructible<First>::value,
+                "First type must be default constructible or variant is not!");
+  this->initialize<0>();
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+// Special member functions
+template <typename First, typename... Types>
+variant<First, Types...>::variant(const variant & rhs) noexcept(
+  detail::variant_noexcept_helper<First, Types...>::nothrow_copy_ctors) {
+  constructor c(*this);
+  apply_visitor(c, rhs);
+  STRICT_VARIANT_ASSERT(rhs.which() == this->which(), "Postcondition failed!");
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+// Note: noexcept is enforced by static_assert in move_constructor visitor
+template <typename First, typename... Types>
+variant<First, Types...>::variant(variant && rhs) noexcept(
+  detail::variant_noexcept_helper<First, Types...>::nothrow_move_ctors) {
+  constructor mc(*this);
+  apply_visitor(mc, std::move(rhs));
+  STRICT_VARIANT_ASSERT(rhs.which() == this->which(), "Postcondition failed!");
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+template <typename First, typename... Types>
+variant<First, Types...> &
+variant<First, Types...>::operator=(const variant & rhs) noexcept(
+  detail::variant_noexcept_helper<First, Types...>::nothrow_copy_assign) {
+  assigner a(*this);
+  apply_visitor(a, rhs);
+  STRICT_VARIANT_ASSERT(rhs.which() == this->which(), "Postcondition failed!");
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+  return *this;
+}
+
+// Note: We want to pierce the recursive_wrapper here, if we move it then
+template <typename First, typename... Types>
+variant<First, Types...> &
+variant<First, Types...>::operator=(variant && rhs) noexcept(
+  detail::variant_noexcept_helper<First, Types...>::nothrow_move_assign) {
+  assigner ma(*this);
+  apply_visitor(ma, std::move(rhs));
+  STRICT_VARIANT_ASSERT(rhs.which() == this->which(), "Postcondition failed!");
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+  return *this;
+}
+
+/// Forwarding-reference ctor
+template <typename First, typename... Types>
+template <typename T, typename>
+variant<First, Types...>::variant(T && t) {
+  static_assert(!std::is_same<variant &, mpl::remove_const_t<T>>::value,
+                "why is variant(T&&) instantiated with a variant? why was a special "
+                "member function not selected?");
+  constexpr unsigned idx = initializer_slot<T>();
+  this->initialize<idx>(std::forward<T>(t));
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+/// Forwarding-reference assignment
+
+template <typename First, typename... Types>
+template <typename T, typename>
+variant<First, Types...> &
+variant<First, Types...>::operator=(T && t) {
+  constexpr unsigned idx = initializer_slot<T>();
+  this->assign<idx>(std::forward<T>(t));
+  return *this;
+}
+
+/// "Generalizing Ctor"
+/// Allow constructing from a variant over a subset of our types
+/// (Boost variant does this, and we need it to comfortably interact with
+/// spirit)
+template <typename First, typename... Types>
+template <typename OFirst, typename... OTypes, typename Enable>
+variant<First, Types...>::variant(const variant<OFirst, OTypes...> & other) noexcept(
+  detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_copy_ctors) {
+  constructor c(*this);
+  apply_visitor(c, other);
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+/// "Generalizing" move ctor, similar as above
+template <typename First, typename... Types>
+template <typename OFirst, typename... OTypes, typename Enable>
+variant<First, Types...>::variant(variant<OFirst, OTypes...> && other) noexcept(
+  detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_move_ctors) {
+  constructor c(*this);
+  apply_visitor(c, std::move(other));
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+}
+
+// Generalizing assignments
+template <typename First, typename... Types>
+template <typename OFirst, typename... OTypes, typename Enable>
+variant<First, Types...> &
+variant<First, Types...>::operator=(const variant<OFirst, OTypes...> & other) noexcept(
+  detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_copy_assign) {
+  assigner a(*this);
+  apply_visitor(a, other);
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+  return *this;
+}
+
+template <typename First, typename... Types>
+template <typename OFirst, typename... OTypes, typename Enable>
+variant<First, Types...> &
+variant<First, Types...>::operator=(variant<OFirst, OTypes...> && other) noexcept(
+  detail::variant_noexcept_helper<OFirst, OTypes...>::nothrow_move_assign) {
+  assigner a(*this);
+  apply_visitor(a, std::move(other));
+  STRICT_VARIANT_ASSERT_WHICH_INVARIANT;
+  return *this;
+}
+
+// Emplace ctor. Used to explicitly specify the type of the variant, and
+// invoke an arbitrary ctor of that type.
+template <typename First, typename... Types>
+template <typename T, typename... Args>
+variant<First, Types...>::variant(emplace_tag<T>, Args &&... args) noexcept(
+  std::is_nothrow_constructible<T, Args...>::value) {
+  constexpr std::size_t idx = find_which<T>::value;
+  static_assert(idx < sizeof...(Types) + 1, "Requested type is not a member of this variant type");
+
+  this->initialize<idx>(std::forward<Args>(args)...);
+}
+
+// Emplace operation
+// In this operation the user explicitly specifies the desired type as
+// template parameter, which must be one of the variant types, modulo const
+// and recursive wrapper.
+// There are two overloads:
+//   when the invoked constructor is noexcept, we destroy the current value
+//     and reinitialize in-place.
+//   when the invoked constructor is not noexcept, we use a move for safety.
+template <typename First, typename... Types>
+template <std::size_t idx, typename... Args>
+auto
+variant<First, Types...>::emplace(Args &&... args) noexcept(false)
+  -> mpl::enable_if_t<!std::is_nothrow_constructible<typename storage_t::template value_t<idx>,
+                                                     Args...>::value> {
+  using temp_t = typename storage_t::template value_t<idx>;
+  static_assert(
+    std::is_nothrow_move_constructible<temp_t>::value,
+    "To use emplace, either the invoked ctor or the move ctor of value type must be noexcept.");
+  temp_t temp(std::forward<Args>(args)...);
+  this->emplace<idx>(std::move(temp));
+}
+
+template <typename First, typename... Types>
+template <std::size_t idx, typename... Args>
+auto
+variant<First, Types...>::emplace(Args &&... args) noexcept
+  -> mpl::enable_if_t<std::is_nothrow_constructible<typename storage_t::template value_t<idx>,
+                                                    Args...>::value> {
+  static_assert(idx < sizeof...(Types) + 1, "Requested type is not a member of this variant type");
+  static_assert(noexcept(this->initialize<idx>(std::forward<Args>(args)...)),
+                "Noexcept assumption failed!");
+
+  this->destroy();
+  this->initialize<idx>(std::forward<Args>(args)...);
+}
+
+// Swap
+
+template <typename First, typename... Types>
+struct variant<First, Types...>::swapper {
+  using var_t = variant<First, Types...>;
+
+  swapper(var_t & lhs_var, var_t & rhs_var)
+    : lhs_(lhs_var)
+    , rhs_(rhs_var) {}
+
+  void do_swap() const noexcept { lhs_.apply_visitor_internal(*this); }
+
+  // First visit is *this, to lhs_var
+  // Second visit is to rhs_var
+  template <typename T>
+  void operator()(T & first_visit) const noexcept {
+    second_visitor<T> v{lhs_, rhs_, first_visit};
+    rhs_.apply_visitor_internal(v);
+  }
+
+  template <typename T>
+  struct second_visitor {
+    var_t & first_var_;
+    var_t & second_var_;
+    T & first_visit_;
+
+    explicit second_visitor(var_t & first_var, var_t & second_var, T & first_visit)
+      : first_var_(first_var)
+      , second_var_(second_var)
+      , first_visit_(first_visit) {}
+
+    // If both give us a T, and T is noexcept swappable, then do that
+    mpl::enable_if_t<mpl::is_nothrow_swappable<T>::value> operator()(T & second_visit) const
+      noexcept {
+      using std::swap;
+      swap(first_visit_, second_visit);
+    }
+
+    // swap using a move
+    template <typename U>
+    void operator()(U & second_visit) const noexcept {
+      constexpr std::size_t t_idx = var_t::find_which<T>::value;
+      constexpr std::size_t u_idx = var_t::find_which<U>::value;
+
+      STRICT_VARIANT_ASSERT(t_idx == first_var_.which(), "Bad access during swap!");
+      STRICT_VARIANT_ASSERT(u_idx == second_var_.which(), "Bad access during swap!");
+
+      T temp{std::move(first_visit_)};
+      first_var_.destroy();
+      first_var_.initialize<u_idx>(std::move(second_visit));
+      second_var_.destroy();
+      second_var_.initialize<t_idx>(std::move(temp));
+    }
+  };
+
+private:
+  var_t & lhs_;
+  var_t & rhs_;
+};
+
+template <typename First, typename... Types>
+void
+variant<First, Types...>::swap(variant & other) noexcept {
+  swapper s{*this, other};
+  s.do_swap();
+}
+
+// Operator ==, !=
+
+// equality check
+// This is essentially a multivisitor, but we do the boiler-plate manually to
+// avoid including extra stuff.
+template <typename First, typename... Types>
+struct eq_checker {
+  typedef bool result_type;
+
+  using var_t = variant<First, Types...>;
+
+  eq_checker(const var_t & lhs_variant)
+    : lhs_v(lhs_variant) {}
+
+  // After we've visited the first value, store it in a function object.
+  // second_visitor<T> is applied to the variant we are passed in ctor.
+  template <typename T>
+  struct second_visitor {
+    const T & r;
+
+    bool operator()(const T & l) const { return l == r; }
+    template <typename U>
+    bool operator()(const U &) const {
+      STRICT_VARIANT_ASSERT(false, "Should be unreachable!");
+      return false;
+    }
+  };
+
+  template <typename Rhs>
+  bool operator()(const Rhs & rhs) const {
+    return apply_visitor(second_visitor<Rhs>{rhs}, lhs_v);
+  }
+
+private:
+  const var_t & lhs_v;
+};
+
+template <typename First, typename... Types>
+inline bool
+operator==(const variant<First, Types...> & lhs, const variant<First, Types...> & rhs) {
+  if (lhs.which() != rhs.which()) { return false; }
+  eq_checker<First, Types...> eq{lhs};
+  return apply_visitor(eq, rhs);
+}
+
+template <typename First, typename... Types>
+inline bool
+operator!=(const variant<First, Types...> & lhs, const variant<First, Types...> & rhs) {
+  return !(lhs == rhs);
+}
+
+} // end namespace strict_variant
+
+#undef STRICT_VARIANT_ASSERT
+#undef STRICT_VARIANT_ASSERT_WHICH_INVARIANT
diff --git a/src/strict_variant/variant_compare.hpp b/src/strict_variant/variant_compare.hpp
new file mode 100644
index 0000000..e9547e0
--- /dev/null
+++ b/src/strict_variant/variant_compare.hpp
@@ -0,0 +1,76 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <functional>
+#include <strict_variant/variant.hpp>
+#include <type_traits>
+
+/***
+ * This variant comparator allows comparing variants which are over
+ * the same set of types, assuming each type involved is less-than comparable
+ * already.
+ * The idea is that first we take "which" of both variants, and if
+ * one is less than the other, then that variant is less overall. Otherwise,
+ * get them both as the same type and compare those.
+ *
+ * This creates a total ordering on the variant values in which the orderings of
+ * each value type sit side by side.
+ *
+ * The template requires a template template parameter, ComparatorTemplate,
+ * which must have an implementation for each value type.
+ * And it requires an `int` comparator to be used for the `which` values.
+ * By default these are `std::less` and `std::less<int>`.
+ */
+
+//[ strict_variant_variant_comparator
+namespace strict_variant {
+
+template <typename T, template <typename> class ComparatorTemplate = std::less,
+          typename WhichComparator_t = std::less<int>>
+struct variant_comparator;
+}
+//]
+
+namespace strict_variant {
+
+template <typename... types, template <typename> class ComparatorTemplate,
+          typename WhichComparator_t>
+struct variant_comparator<variant<types...>, ComparatorTemplate, WhichComparator_t> {
+
+  typedef variant<types...> var_t;
+
+  struct helper {
+
+    const var_t & first;
+    const var_t & other;
+
+    explicit helper(const var_t & _f, const var_t & _o)
+      : first(_f)
+      , other(_o) {}
+
+    template <typename T>
+    bool operator()(const T & t) const {
+      if (const T * o = strict_variant::get<T>(&other)) {
+        ComparatorTemplate<T> c;
+        return c(t, *o);
+      } else {
+        static_assert(std::is_same<int, decltype(first.which())>::value,
+                      "The return type of 'variant::which' was changed and "
+                      "variant_compare was not updated");
+        WhichComparator_t c;
+        return c(first.which(), other.which());
+      }
+    }
+  };
+
+  bool operator()(const var_t & v1, const var_t & v2) const {
+    helper h{v1, v2};
+    return strict_variant::apply_visitor(h, v1);
+  }
+};
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/variant_detail.hpp b/src/strict_variant/variant_detail.hpp
new file mode 100644
index 0000000..92399e9
--- /dev/null
+++ b/src/strict_variant/variant_detail.hpp
@@ -0,0 +1,196 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/find_with.hpp>
+#include <strict_variant/safely_constructible.hpp>
+#include <strict_variant/variant_fwd.hpp>
+#include <strict_variant/wrapper.hpp>
+
+#include <type_traits>
+
+/***
+ * Traits to help with SFINAE in variant class template
+ */
+
+namespace strict_variant {
+
+namespace detail {
+
+// Search prediate for find_which
+// Checks if type T and type U are the same, modulo const and recursive wrapper
+template <typename T>
+struct same_modulo_const_ref_wrapper {
+  template <typename U>
+  struct prop {
+    using T2 = unwrap_type_t<mpl::remove_const_t<mpl::remove_reference_t<T>>>;
+    using U2 = unwrap_type_t<mpl::remove_const_t<mpl::remove_reference_t<U>>>;
+
+    static constexpr bool value = std::is_same<T2, U2>::value;
+  };
+};
+
+/***
+ * Property `is_member_modulo_const_ref_wrappr` checks if an element is in a
+ * list, modulo const and recursive wrapper.
+ */
+template <typename... Ts>
+struct is_member_modulo_const_ref_wrapper {
+  template <typename U>
+  struct prop {
+    static constexpr bool value =
+      mpl::Find_Any<same_modulo_const_ref_wrapper<U>::template prop, Ts...>::value;
+  };
+};
+
+/***
+ * Metafunction `subvariant`: Check if the set of types of A is a subset of the
+ * set of types of B, modulo const and reference_wrapper
+ */
+template <typename A, typename B>
+struct subvariant;
+
+template <typename... As, typename... Bs>
+struct subvariant<variant<As...>, variant<Bs...>> {
+  static constexpr bool value =
+    mpl::All_Have<is_member_modulo_const_ref_wrapper<Bs...>::template prop, As...>::value;
+};
+
+/***
+ * Metafunction `proper_subvariant`:
+ *   Check both `subvariant<A, B>::value` and `!std::is_same<A, B>::value`.
+ *   This is used to select when we should use "generalizing" ctor of variant,
+ *   rather than one of the usual special member functions.
+ *
+ *   Note that it's possible that sizeof...(As) == sizeof...(Bs) but this
+ *   doesn't cause any bugs so it's ok -- it just means that
+ *   `variant<int, double>` is constructible from `variant<double, int>`, which
+ *   is fine.
+ */
+template <typename A, typename B>
+struct proper_subvariant {
+  static constexpr bool value = !std::is_same<A, B>::value && subvariant<A, B>::value;
+};
+
+/****
+ * NOEXCEPT TRAITS
+ *
+ * Traits to help with moveability / copyability in variant.
+ * The trick is that we need to support the case when recursive_wrapper is incomplete.
+ */
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_moveable_or_wrapper_impl : std::is_nothrow_move_constructible<T> {};
+
+template <typename T>
+struct is_nothrow_moveable_or_wrapper_impl<T, true> : std::true_type {};
+
+template <typename T>
+struct is_nothrow_moveable_or_wrapper : is_nothrow_moveable_or_wrapper_impl<T> {};
+
+// Subtle point:
+// Generally, moving T && into recursive_wrapper<T> is not no-throw, since
+// we have to make a dynamic allocation. So traits below are appropriate for
+// determining the *variant*'s noexcept status.
+// Trait above is useful for figuring out if assingment can work.
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_default_constructible_impl : std::is_nothrow_default_constructible<T> {};
+
+template <typename T>
+struct is_nothrow_default_constructible_impl<T, true> : std::false_type {};
+
+template <typename T>
+struct is_nothrow_default_constructible : is_nothrow_default_constructible_impl<T> {};
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_moveable_impl : std::is_nothrow_move_constructible<T> {};
+
+template <typename T>
+struct is_nothrow_moveable_impl<T, true> : std::false_type {};
+
+template <typename T>
+struct is_nothrow_moveable : is_nothrow_moveable_impl<T> {};
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_copyable_impl : std::is_nothrow_constructible<T, const T &> {};
+
+template <typename T> // Just assume it isn't, since it may be incomplete
+struct is_nothrow_copyable_impl<T, true> : std::false_type {};
+
+template <typename T>
+struct is_nothrow_copyable : is_nothrow_copyable_impl<T> {};
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_move_assignable_impl : std::is_nothrow_move_assignable<T> {};
+
+template <typename T>
+struct is_nothrow_move_assignable_impl<T, true> : std::false_type {};
+
+template <typename T>
+struct is_nothrow_move_assignable : is_nothrow_move_assignable_impl<T> {};
+
+template <typename T, bool b = is_wrapper<T>::value>
+struct is_nothrow_copy_assignable_impl : std::is_nothrow_copy_assignable<T> {};
+
+template <typename T>
+struct is_nothrow_copy_assignable_impl<T, true> : std::false_type {};
+
+template <typename T>
+struct is_nothrow_copy_assignable : is_nothrow_copy_assignable_impl<T> {};
+
+template <typename First, typename... Types>
+struct variant_noexcept_helper {
+  /***
+   * Configuration
+   */
+
+  // Treat all input types as if they were nothrow moveable,
+  // regardless of their noexcept declarations.
+  // (Note: It is a core assumption of the variant that these operations don't
+  //  throw, you will get UB and likely an immediate crash if they do throw.
+  //  Only use this as a workaround for e.g. old code which is not
+  //  noexcept-correct. For instance if you require compatibility with a
+  //  gcc-4-series version of libstdc++ and std::string isn't noexcept.)
+  static constexpr bool assume_move_nothrow =
+#ifdef STRICT_VARIANT_ASSUME_MOVE_NOTHROW
+    true;
+#else
+    false;
+#endif
+
+  // Treat all input types as if they were nothrow copyable,
+  // regardless of thier noexcept declarations.
+  // (Note: This is usually quite risky, only appropriate in projects which
+  //  assume already that dynamic memory allocation will never fail, and want to
+  //  go as fast as possible given that assumption.)
+  static constexpr bool assume_copy_nothrow =
+#ifdef STRICT_VARIANT_ASSUME_COPY_NOTHROW
+    true;
+#else
+    false;
+#endif
+
+  static constexpr bool assignable =
+    assume_move_nothrow
+    || mpl::All_Have<detail::is_nothrow_moveable_or_wrapper, First, Types...>::value;
+
+  static constexpr bool nothrow_move_ctors =
+    assume_move_nothrow || mpl::All_Have<detail::is_nothrow_moveable, First, Types...>::value;
+
+  static constexpr bool nothrow_copy_ctors =
+    assume_copy_nothrow || mpl::All_Have<detail::is_nothrow_copyable, First, Types...>::value;
+
+  static constexpr bool nothrow_move_assign =
+    nothrow_move_ctors && mpl::All_Have<detail::is_nothrow_move_assignable, First, Types...>::value;
+
+  static constexpr bool nothrow_copy_assign =
+    nothrow_copy_ctors && mpl::All_Have<detail::is_nothrow_copy_assignable, First, Types...>::value;
+};
+
+} // end namespace detail
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/variant_dispatch.hpp b/src/strict_variant/variant_dispatch.hpp
new file mode 100644
index 0000000..6444c81
--- /dev/null
+++ b/src/strict_variant/variant_dispatch.hpp
@@ -0,0 +1,225 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/find_with.hpp>
+#include <strict_variant/mpl/nonstd_traits.hpp>
+#include <strict_variant/mpl/std_traits.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+#include <strict_variant/mpl/ulist.hpp>
+#include <strict_variant/variant_fwd.hpp>
+
+#include <type_traits>
+#include <utility>
+
+#ifdef STRICT_VARIANT_DEBUG
+#include <cassert>
+
+#define STRICT_VARIANT_ASSERT(X)                                                                   \
+  do {                                                                                             \
+    assert((X));                                                                                   \
+  } while (0)
+
+#else // STRICT_VARIANT_DEBUG
+
+#define STRICT_VARIANT_ASSERT(X)                                                                   \
+  do {                                                                                             \
+    static_cast<void>(X);                                                                          \
+  } while (0)
+
+#endif // STRICT_VARIANT_DEBUG
+
+namespace strict_variant {
+
+namespace detail {
+
+/***
+ * Dispatch mechanism:
+ *   These two templates are used to dispatch visitor objects to
+ *   the variant's storage. The problem that is being solved here is,
+ *   how do we actually recover type information from the runtime
+ *   value of `m_which`, so that we can call the appropriate overload
+ *   of a visitor to the variant.
+ */
+
+/// Function which evaluates a visitor against a variant's internals
+/// Reinteprets the "storage" as a value of type T or const T,
+/// then applies the visitor object.
+#define RESULT_EXPR                                                                                \
+  std::forward<Visitor>(v)(std::forward<Storage>(s).template get_value<index>(Internal()))
+
+template <unsigned index, typename Internal, typename Storage, typename Visitor>
+auto
+visitor_caller(Storage && s, Visitor && v) noexcept(noexcept(RESULT_EXPR))
+  -> decltype(RESULT_EXPR) {
+  return RESULT_EXPR;
+}
+
+#undef RESULT_EXPR
+
+/// Helper which figures out the return type of multiple visitor calls
+/// It's better for this to be separate of the dispatch mechanism, because
+/// std::common_type can technically be order dependent. It's confusing if the
+/// return type can change depending on the dispatch strategy used, and it
+/// simplifies the dispatch code to only have to implement this once.
+template <typename Internal, typename Storage, typename Visitor>
+struct return_typer {
+
+#define RESULT_EXPR                                                                                \
+  visitor_caller<index, Internal, Storage>(std::forward<Storage>(std::declval<Storage>()),         \
+                                           std::forward<Visitor>(std::declval<Visitor>()))
+
+  template <unsigned index>
+  struct at_index {
+    using type = decltype(RESULT_EXPR);
+  };
+
+  template <unsigned index>
+  struct noexcept_prop {
+    static constexpr bool value = noexcept(RESULT_EXPR);
+    using type = std::integral_constant<bool, value>;
+  };
+
+#undef RESULT_EXPR
+};
+
+/// Helper object which dispatches a visitor object to the appropriate
+/// interpretation of our storage value, based on value of "which".
+///
+/// The solution here is that for each possible value of `which`, we create an
+/// appropriate function using the above function template, and store them each
+/// in an array, using parameter pack expansion. (A little 'jump table'.)
+///
+/// Then we dereference the array at index `m_which` and call that function.
+/// This means we pick out the right function very quickly, but it may not be
+/// inlined by the compiler even if it is small.
+
+template <typename return_t, typename Internal, typename ulist>
+struct jumptable_dispatch;
+
+template <typename return_t, typename Internal, unsigned... Indices>
+struct jumptable_dispatch<return_t, Internal, mpl::ulist<Indices...>> {
+  template <typename Storage, typename Visitor>
+  return_t operator()(const unsigned int which, Storage && storage, Visitor && visitor)
+
+  {
+    using whichCaller = return_t (*)(Storage, Visitor);
+
+    static whichCaller callers[sizeof...(Indices)] = {
+      &visitor_caller<Indices, Internal, Storage, Visitor>...};
+
+    STRICT_VARIANT_ASSERT(which < static_cast<unsigned int>(sizeof...(Indices)));
+
+    return (*callers[which])(std::forward<Storage>(storage), std::forward<Visitor>(visitor));
+  }
+};
+
+/// Same as the above, but we use a different strategy based on a binary tree,
+/// and repeated testing of the "which" value.
+///
+/// The idea is that if there are multiple types, we just test if we are looking
+/// in the first half or the second half, and branch to two different
+/// instantiations of the binary_search_dispatch object as appropriate.
+///
+/// When arranged this way, the compiler can always inline the visitor calls,
+/// and so for variants with few types this may be significantly faster.
+///
+/// The "which" value is not changed even as the type list gets smaller,
+/// instead, the "base" value is increased.
+
+template <typename return_t, typename Internal, unsigned int base, unsigned int num_types>
+struct binary_search_dispatch {
+  static_assert(num_types >= 2, "Something wrong with binary search dispatch");
+
+  static constexpr unsigned int half = num_types / 2;
+
+  template <typename Storage, typename Visitor>
+  return_t operator()(const unsigned int which, Storage && storage, Visitor && visitor) {
+
+    if (which < base + half) {
+      return binary_search_dispatch<return_t, Internal, base, half>{}(
+        which, std::forward<Storage>(storage), std::forward<Visitor>(visitor));
+    } else {
+      return binary_search_dispatch<return_t, Internal, base + half, num_types - half>{}(
+        which, std::forward<Storage>(storage), std::forward<Visitor>(visitor));
+    }
+  }
+};
+
+template <typename return_t, typename Internal, unsigned int base>
+struct binary_search_dispatch<return_t, Internal, base, 1u> {
+  template <typename Storage, typename Visitor>
+  return_t operator()(const unsigned int which, Storage && storage, Visitor && visitor) {
+    STRICT_VARIANT_ASSERT(which == base);
+
+    return visitor_caller<base, Internal, Storage, Visitor>(std::forward<Storage>(storage),
+                                                            std::forward<Visitor>(visitor));
+  }
+};
+
+/// Choose the jumptable dispatch strategy when the number of types is > switch
+/// point
+/// choose the binary search dispatch for less than that.
+/// Tentatively choosing 4 for switch point, potentially 8 is better... ?
+/// Needs more rigorous benchmarking
+template <typename Internal, size_t num_types>
+struct visitor_dispatch {
+  // static constexpr unsigned int switch_point = 4;
+
+  // Helper which takes the conjunction of a typelist of `std::integral_constant<bool>`.
+  template <typename T>
+  struct conjunction;
+
+  template <typename... Types>
+  struct conjunction<mpl::TypeList<Types...>> {
+    template <typename T>
+    struct is_false_prop : std::is_same<T, std::integral_constant<bool, false>> {};
+
+    static constexpr bool value = !mpl::Find_Any<is_false_prop, Types...>::value;
+  };
+
+  // Helper which figures out return type and noexcept status, for given storage and visitor
+  template <typename Storage, typename Visitor>
+  struct call_helper {
+    using rtyper = return_typer<Internal, Storage, Visitor>;
+    using indices = mpl::count_t<num_types>;
+
+    static constexpr bool noexcept_value =
+      conjunction<mpl::ulist_map_t<rtyper::template noexcept_prop, indices>>::value;
+
+    using return_type =
+      typename mpl::typelist_fwd<mpl::common_return_type_t,
+                                 mpl::ulist_map_t<rtyper::template at_index, indices>>::type;
+  };
+
+  // Invoke the actual dispatcher
+  template <typename Storage, typename Visitor>
+  auto operator()(const unsigned int which, Storage && storage,
+                  Visitor && visitor) noexcept(call_helper<Storage, Visitor>::noexcept_value) ->
+    typename call_helper<Storage, Visitor>::return_type {
+
+    using return_t = typename call_helper<Storage, Visitor>::return_type;
+
+    // using chosen_dispatch_t = jumptable_dispatch<return_t, Internal, mpl::count_t<num_types>>;
+
+    // using chosen_dispatch_t =
+    //  typename std::conditional<(num_types > switch_point),
+    //  jumptable_dispatch<return_t, Internal,  mpl::count_t<num_types>>,
+    //                            binary_search_dispatch<return_t, Internal, 0,
+    //                             num_types>>::type;
+
+    using chosen_dispatch_t = binary_search_dispatch<return_t, Internal, 0, num_types>;
+
+    return chosen_dispatch_t{}(which, std::forward<Storage>(storage),
+                               std::forward<Visitor>(visitor));
+  }
+};
+
+} // end namespace detail
+
+} // end namespace strict_variant
+
+#undef STRICT_VARIANT_ASSERT
diff --git a/src/strict_variant/variant_fwd.hpp b/src/strict_variant/variant_fwd.hpp
new file mode 100644
index 0000000..96f962d
--- /dev/null
+++ b/src/strict_variant/variant_fwd.hpp
@@ -0,0 +1,16 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+namespace strict_variant {
+
+template <typename T>
+class recursive_wrapper;
+
+template <typename First, typename... Types>
+class variant;
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/variant_hash.hpp b/src/strict_variant/variant_hash.hpp
new file mode 100644
index 0000000..76b2cf5
--- /dev/null
+++ b/src/strict_variant/variant_hash.hpp
@@ -0,0 +1,36 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <strict_variant/variant.hpp>
+
+//- hash support:
+namespace std {
+
+template <typename... Ts>
+struct hash<strict_variant::variant<Ts...>> {
+
+  using argument_type = strict_variant::variant<Ts...>;
+  using result_type = std::size_t;
+
+private:
+  struct hasher {
+    using result_type = std::size_t;
+    template <typename Arg>
+    std::size_t operator()(const Arg & arg) const {
+      return std::hash<Arg>{}(arg);
+    }
+  }; // hasher
+
+public:
+  std::size_t operator()(const argument_type & v) const {
+    return strict_variant::apply_visitor(hasher{}, v) + (31 * v.which());
+  }
+}; // hash<strict_variant::variant<Ts...>>
+
+} // namespace std
diff --git a/src/strict_variant/variant_spirit.hpp b/src/strict_variant/variant_spirit.hpp
new file mode 100644
index 0000000..217a2be
--- /dev/null
+++ b/src/strict_variant/variant_spirit.hpp
@@ -0,0 +1,90 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/find_with.hpp>
+#include <strict_variant/variant_fwd.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/spirit/home/support.hpp>
+#include <type_traits>
+
+/***
+ * Add a trait within boost spirit so that strict_variant can be parsed using the
+ * alternative parser operator |, just like boost::variant.
+ */
+
+// First a helper metafunction
+namespace strict_variant {
+namespace mpl {
+
+// index_at_or_fallback
+template <std::size_t n, typename fallback, typename... Types>
+struct Index_At_Or_Fallback;
+
+template <std::size_t n, typename F, typename T, typename... Ts>
+struct Index_At_Or_Fallback<n, F, T, Ts...> : Index_At_Or_Fallback<n - 1, F, Ts...> {};
+
+template <typename F, typename T, typename... Ts>
+struct Index_At_Or_Fallback<0, F, T, Ts...> {
+  typedef T type;
+};
+
+template <std::size_t n, typename F>
+struct Index_At_Or_Fallback<n, F> {
+  typedef F type;
+};
+
+} // end namespace mpl
+} // end namespace strict_variant
+
+// Now the qi parts
+namespace boost {
+namespace spirit {
+namespace traits {
+
+// forward declare the trait
+template <typename T, typename Domain, typename Enable /* = void*/>
+struct not_is_variant;
+
+// mpl::false_ here is why we need to include boost mpl
+template <typename First, typename... Types, typename Domain>
+struct not_is_variant<strict_variant::variant<First, Types...>, Domain, void> : mpl::false_ {};
+
+} // end namespace traits
+
+// Add implementation for "find_substitute"
+
+namespace qi {
+namespace detail {
+
+// declaration
+template <typename Variant, typename Expected>
+struct find_substitute;
+
+template <typename... Types, typename Expected>
+struct find_substitute<strict_variant::variant<Types...>, Expected> {
+  template <typename T>
+  struct same_prop : std::is_same<T, Expected> {};
+
+  static constexpr size_t same_idx = strict_variant::mpl::Find_With<same_prop, Types...>::value;
+
+  template <typename T>
+  struct conv_prop : traits::is_substitute<T, Expected> {};
+
+  static constexpr size_t same_or_conv_idx =
+    (same_idx < sizeof...(Types)) ? same_idx
+                                  : strict_variant::mpl::Find_With<conv_prop, Types...>::value;
+
+  typedef typename strict_variant::mpl::Index_At_Or_Fallback<same_or_conv_idx, Expected,
+                                                             Types...>::type type;
+};
+
+} // end namespace detail
+} // end namespace qi
+
+} // end namespace spirit
+} // end namespace boost
diff --git a/src/strict_variant/variant_storage.hpp b/src/strict_variant/variant_storage.hpp
new file mode 100644
index 0000000..2010aef
--- /dev/null
+++ b/src/strict_variant/variant_storage.hpp
@@ -0,0 +1,117 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <new>
+#include <strict_variant/mpl/max.hpp>
+#include <strict_variant/mpl/typelist.hpp>
+#include <strict_variant/wrapper.hpp>
+#include <utility>
+
+namespace strict_variant {
+namespace detail {
+
+// Implementation note:
+// Internal visitors need to be able to access the "true" type, the
+// reference_wrapper<T> when it is within the variant, to implement ctors
+// and special memeber functions.
+// External visitors are supposed to have this elided.
+// The `get_value` function uses tag dispatch to do the right thing.
+
+struct true_ {};
+struct false_ {};
+
+// Storage for the types in a list of types.
+// Provides typed access using the index within the list as a template parameter.
+// And some facilities for piercing recursive_wrapper
+
+template <typename First, typename... Types>
+struct storage {
+
+  /***
+   * Determine size and alignment of our storage
+   */
+  template <typename T>
+  struct Sizeof {
+    static constexpr size_t value = sizeof(T);
+  };
+
+  template <typename T>
+  struct Alignof {
+    static constexpr size_t value = alignof(T);
+  };
+
+  // size = max of size of each thing
+  static constexpr size_t m_size = mpl::max<Sizeof, First, Types...>::value;
+
+  // align = max align of each thing
+  static constexpr size_t m_align = mpl::max<Alignof, First, Types...>::value;
+
+  /***
+   * Storage
+   */
+
+  // alignas(m_align) char m_storage[m_size];
+  using aligned_storage_t = typename std::aligned_storage<m_size, m_align>::type;
+  aligned_storage_t m_storage;
+
+  void * address() { return reinterpret_cast<void *>(&m_storage); }
+  const void * address() const { return reinterpret_cast<const void *>(&m_storage); }
+
+  /***
+   * Index -> Type
+   */
+  using my_types = mpl::TypeList<First, Types...>;
+
+  template <size_t index>
+  using value_t = mpl::Index_At<my_types, index>;
+
+  /***
+   * Initialize to the type at a particular value
+   */
+  template <size_t index, typename... Args>
+  void initialize(Args &&... args) noexcept(
+    noexcept(value_t<index>(std::forward<Args>(std::declval<Args>())...))) {
+    new (this->address()) value_t<index>(std::forward<Args>(args)...);
+  }
+
+  /***
+   * Typed access which pierces recursive_wrapper if detail::false_ is passed
+   * "Internal" (non-piercing) access is achieved if detail::true_ is passed
+   */
+  template <size_t index>
+  value_t<index> & get_value(detail::true_) & {
+    return *reinterpret_cast<value_t<index> *>(this->address());
+  }
+
+  template <size_t index>
+  const value_t<index> & get_value(detail::true_) const & {
+    return *reinterpret_cast<const value_t<index> *>(this->address());
+  }
+
+  template <size_t index>
+  value_t<index> && get_value(detail::true_) && {
+    return std::move(*reinterpret_cast<value_t<index> *>(this->address()));
+  }
+
+  template <size_t index>
+  unwrap_type_t<value_t<index>> & get_value(detail::false_) & {
+    return detail::pierce_wrapper(this->get_value<index>(detail::true_{}));
+  }
+
+  template <size_t index>
+  const unwrap_type_t<value_t<index>> & get_value(detail::false_) const & {
+    return detail::pierce_wrapper(this->get_value<index>(detail::true_{}));
+  }
+
+  template <size_t index>
+  unwrap_type_t<value_t<index>> && get_value(detail::false_) && {
+    return std::move(detail::pierce_wrapper(this->get_value<index>(detail::true_{})));
+  }
+};
+
+} // end namespace detail
+} // end namespace strict_variant
diff --git a/src/strict_variant/variant_stream_ops.hpp b/src/strict_variant/variant_stream_ops.hpp
new file mode 100644
index 0000000..338ca17
--- /dev/null
+++ b/src/strict_variant/variant_stream_ops.hpp
@@ -0,0 +1,43 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+/***
+ * Enable streaming operations for variant types
+ */
+
+#include <iosfwd>
+#include <strict_variant/variant.hpp>
+
+namespace strict_variant {
+
+// printer
+struct printer_visitor {
+  typedef void result_type;
+  explicit printer_visitor(std::ostream & ss)
+    : m_ss(ss) {}
+
+  template <typename T>
+  void operator()(const T & t) const {
+    m_ss << t;
+  }
+
+private:
+  std::ostream & m_ss;
+};
+
+/***
+ * ostream op
+ */
+template <typename First, typename... Types>
+std::ostream &
+operator<<(std::ostream & s, const variant<First, Types...> & v) {
+  printer_visitor vis{s};
+  strict_variant::apply_visitor(vis, v);
+  return s;
+}
+
+} // end namespace strict_variant
diff --git a/src/strict_variant/version.hpp b/src/strict_variant/version.hpp
new file mode 100644
index 0000000..787c3fc
--- /dev/null
+++ b/src/strict_variant/version.hpp
@@ -0,0 +1,10 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#define STRICT_VARIANT_VERSION_MAJOR 0
+#define STRICT_VARIANT_VERSION_MINOR 4
+#define STRICT_VARIANT_VERSION_PATCH 0
diff --git a/src/strict_variant/wrapper.hpp b/src/strict_variant/wrapper.hpp
new file mode 100644
index 0000000..92be64f
--- /dev/null
+++ b/src/strict_variant/wrapper.hpp
@@ -0,0 +1,73 @@
+//  (C) Copyright 2016 - 2018 Christopher Beck
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <strict_variant/mpl/std_traits.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace strict_variant {
+
+//[ strict_variant_is_recursive_wrapper
+namespace detail {
+
+/***
+ * Trait to identify wrapper types like recursive_wrapper.
+ * Specialize this trait to make strict_variant recognize and automatically
+ * pierce custom wrappers.
+ */
+
+template <typename T>
+struct is_wrapper : std::false_type {};
+
+} // end namespace detail
+//]
+
+//[ strict_variant_pierce_wrapper
+namespace detail {
+
+/***
+ * Function to pierce a wrapper
+ */
+
+template <typename T>
+inline auto
+pierce_wrapper(T && t)
+  -> mpl::enable_if_t<!is_wrapper<mpl::remove_const_t<mpl::remove_reference_t<T>>>::value, T> {
+  return std::forward<T>(t);
+}
+
+template <typename T>
+inline auto
+pierce_wrapper(T && t)
+  -> mpl::enable_if_t<is_wrapper<mpl::remove_const_t<mpl::remove_reference_t<T>>>::value,
+                      decltype(std::forward<T>(t).get())> {
+  return std::forward<T>(t).get();
+}
+
+} // end namespace detail
+  //]
+
+/***
+ * Trait to remove a wrapper from a wrapped type
+ */
+template <typename T, bool is_wrapped = detail::is_wrapper<T>::value>
+struct unwrap_type;
+
+template <typename T>
+struct unwrap_type<T, false> {
+  typedef T type;
+};
+
+template <typename T>
+struct unwrap_type<T, true> {
+  typedef typename T::value_type type;
+};
+
+template <typename T>
+using unwrap_type_t = typename unwrap_type<T>::type;
+
+} // end namespace strict_variant