diff --git a/src/neo/core/tuple.detail.hpp b/src/neo/core/tuple.detail.hpp
new file mode 100644
index 0000000..d9042b3
--- /dev/null
+++ b/src/neo/core/tuple.detail.hpp
@@ -0,0 +1,117 @@
+#pragma once
+
+#include <neo/attrib.hpp>
+#include <neo/compare.hpp>
+#include <neo/get.hpp>
+#include <neo/object_t.hpp>
+#include <neo/type_traits.hpp>
+
+#include <compare>
+#include <tuple>
+#include <utility>
+
+namespace neo::core::_tuple_detail {
+
+/// An indexed box to hold tuple elements
+template <std::size_t, typename T>
+struct nth_box {
+    // The value for this element
+    NEO_NO_UNIQUE_ADDRESS object_t<T> _obox;
+
+    using lref = add_lvalue_reference_t<nonvoid_t<T>>;
+    using cref = add_const_reference_t<nonvoid_t<T>>;
+
+    constexpr nth_box() = default;
+    constexpr explicit nth_box(std::in_place_t, auto&& t)
+        : _obox(NEO_FWD(t)) {}
+
+    bool operator==(nth_box const&) const  = default;
+    auto operator<=>(nth_box const&) const = default;
+
+    constexpr lref get() noexcept { return static_cast<lref>(_obox); }
+    constexpr cref get() const noexcept { return static_cast<cref>(_obox); }
+};
+
+template <typename Tpl, typename Seq = std::make_index_sequence<meta::len_v<Tpl>>>
+struct boxes;
+
+template <std::size_t... Is, neo_ttparam Tpl, typename... Ts>
+struct boxes<Tpl<Ts...>, std::index_sequence<Is...>> : nth_box<Is, Ts>... {
+    constexpr boxes() = default;
+
+    template <typename... Args>
+    constexpr explicit boxes(std::in_place_t tag, Args&&... args)  //
+        : nth_box<Is, Ts>(tag, NEO_FWD(args))... {}
+
+    bool operator==(boxes const&) const  = default;
+    auto operator<=>(boxes const&) const = default;
+};
+
+template <std::size_t... Ns>
+constexpr bool equal(const auto& left, const auto& right, std::index_sequence<Ns...>) noexcept {
+    return (static_cast<bool>(left.template get<Ns>() == right.template get<Ns>()) and ...);
+}
+
+template <typename T, typename U, std::size_t... Ns>
+constexpr auto compare_three_way(const T& lhs, const U& rhs, std::index_sequence<Ns...>) noexcept {
+    using Category = std::common_comparison_category_t<
+        std::compare_three_way_result_t<decltype(lhs.template get<Ns>()),
+                                        decltype(rhs.template get<Ns>())>...>;
+    Category ret = std::strong_ordering::equal;
+    static_cast<void>(
+        ((0 != (ret = synth_three_way(lhs.template get<Ns>(), rhs.template get<Ns>()))) or ...
+         or true));
+    return ret;
+}
+
+template <typename L>
+    requires requires { std::tuple_size<L>::value; }
+using index_sequence_for_tpl = std::make_index_sequence<std::tuple_size_v<L>>;
+
+template <typename Tpl, std::size_t... Ns>
+    requires(can_get_nth<Tpl, Ns> and ...)
+constexpr void tuple_like_check(Tpl&& tpl, std::index_sequence<Ns...>);
+
+template <typename Tpl>
+concept tuple_like = requires(Tpl&& tpl) {
+    typename index_sequence_for_tpl<remove_cvref_t<Tpl>>;
+    tuple_like_check(static_cast<Tpl&&>(tpl), index_sequence_for_tpl<remove_cvref_t<Tpl>>{});
+};
+
+template <typename OtherTpl, typename BaseTpl>
+concept matching_tuple_like = tuple_like<OtherTpl>
+    and std::tuple_size_v<remove_cvref_t<OtherTpl>> == std::tuple_size_v<BaseTpl>;
+
+template <typename Tpl, typename Argument, std::size_t... Ns>
+    requires(
+        (std::constructible_from<object_t<std::tuple_element_t<Ns, Tpl>>, get_nth_t<Argument, Ns>>
+         and ...))
+void check_tuple_constructible(std::index_sequence<Ns...>);
+
+template <typename Tpl, typename Argument>
+concept tuple_constructible = matching_tuple_like<Argument, Tpl> and requires(Argument&& from) {
+    check_tuple_constructible<Tpl, Argument>(index_sequence_for_tpl<Tpl>{});
+};
+
+template <typename FromTpl, typename ToTpl, std::size_t... Ns>
+    requires((std::convertible_to<get_nth_t<FromTpl, Ns>, object_t<std::tuple_element_t<Ns, ToTpl>>>
+              and ...))
+void check_tuple_convertible(std::index_sequence<Ns...>);
+
+template <typename FromTpl, typename ToTpl>
+concept tuple_convertible = tuple_constructible<ToTpl, FromTpl>
+    and requires { check_tuple_convertible<FromTpl, ToTpl>(index_sequence_for_tpl<ToTpl>{}); };
+
+template <typename ToTpl, typename Argument, std::size_t... Ns>
+    requires((nothrow_constructible_from<object_t<std::tuple_element_t<Ns, ToTpl>>,
+                                         get_nth_t<Argument, Ns>>
+              and ...))
+void check_tuple_construct_nothrow(std::index_sequence<Ns...>);
+
+template <typename ToTpl, typename Argument>
+concept tuple_construct_nothrow
+    = tuple_constructible<ToTpl, Argument> and requires(Argument&& from) {
+          check_tuple_construct_nothrow<ToTpl, Argument>(index_sequence_for_tpl<ToTpl>{});
+      };
+
+}  // namespace neo::core::_tuple_detail
diff --git a/src/neo/core/tuple.hpp b/src/neo/core/tuple.hpp
new file mode 100644
index 0000000..10c4bf5
--- /dev/null
+++ b/src/neo/core/tuple.hpp
@@ -0,0 +1,249 @@
+#pragma once
+
+#include "./tuple.detail.hpp"
+
+#include <neo/attrib.hpp>
+#include <neo/concepts.hpp>
+#include <neo/get.hpp>
+#include <neo/meta.hpp>
+
+#include <utility>
+
+namespace neo {
+
+// Tag used to select the piece-wise constructor for a tuple
+struct tuple_construct_tag {};
+// Tag to select a tuple->tuple converting constructor
+struct tuple_convert_tag {};
+
+}  // namespace neo
+
+namespace neo::core {
+
+/**
+ * @brief A core::tuple is like a full neo::tuple but provides a simpler interface
+ * upon which the more expressive interface is constructed.
+ */
+template <typename... Ts>
+class tuple {
+public:
+    using index_sequence = std::make_index_sequence<sizeof...(Ts)>;
+
+    template <std::size_t N>
+    using nth_type = nonvoid_t<meta::pack_at<N, Ts...>>;
+
+private:
+    using boxes = _tuple_detail::boxes<tuple>;
+
+    NEO_NO_UNIQUE_ADDRESS boxes _boxes;
+
+    template <std::size_t N>
+    using _nth_box = _tuple_detail::nth_box<N, meta::pack_at<N, Ts...>>;
+
+public:
+    tuple() = default;
+
+    /**
+     * @brief Tuple per-element-converting constructor.
+     *
+     * @param tag A tag to select this constructor
+     * @param args... Arguments that will be converted to the tuple elements.
+     */
+    template <typename... Args>
+    constexpr explicit tuple(tuple_construct_tag,
+                             Args&&... args)  //
+        noexcept((nothrow_constructible_from<nonvoid_t<Ts>, Args> and ...))
+        : _boxes(std::in_place, NEO_FWD(args)...) {}
+
+    /**
+     * @brief From-tuple converting constructor. Converts from another tuple-like
+     * object (using neo::get_nth<N>) for each tuple element.
+     *
+     * @param tag The tag to select this constructor
+     * @param tpl The tuple-like object to construct from. Elements will be perfect-forwarded from
+     * this tuple
+     */
+    template <typename Tpl, auto... N>
+    constexpr explicit tuple(tuple_convert_tag,
+                             Tpl&& tpl,
+                             std::index_sequence<N...>)  //
+        noexcept((nothrow_constructible_from<nonvoid_t<Ts>, get_nth_t<Tpl, N>> and ...))
+        : _boxes(std::in_place, get_nth<N>(NEO_FWD(tpl))...) {}
+
+    template <std::size_t N>
+    constexpr add_lvalue_reference_t<nth_type<N>> get() & noexcept {
+        auto& box = static_cast<_nth_box<N>&>(_boxes);
+        return static_cast<add_lvalue_reference_t<nth_type<N>>>(box.get());
+    }
+
+    template <std::size_t N>
+    constexpr add_lvalue_reference_t<const nth_type<N>> get() const& noexcept {
+        auto& box = static_cast<const _nth_box<N>&>(_boxes);
+        return static_cast<add_lvalue_reference_t<const nth_type<N>>>(box.get());
+    }
+
+    template <std::size_t N>
+    constexpr add_rvalue_reference_t<nth_type<N>> get() && noexcept {
+        auto& box = static_cast<_nth_box<N>&>(_boxes);
+        return static_cast<add_rvalue_reference_t<nth_type<N>>>(box.get());
+    }
+
+    template <std::size_t N>
+    constexpr add_rvalue_reference_t<const nth_type<N>> get() const&& noexcept {
+        auto& box = static_cast<const _nth_box<N>&>(_boxes);
+        return static_cast<add_rvalue_reference_t<const nth_type<N>>>(box.get());
+    }
+
+    bool operator==(tuple const&) const  = default;
+    auto operator<=>(tuple const&) const = default;
+};
+
+// Specialization of an empty tuple
+template <>
+class tuple<> {
+public:
+    using index_sequence = std::index_sequence<>;
+
+    tuple() = default;
+    constexpr explicit tuple(tuple_construct_tag) noexcept {}
+    template <typename Tpl>
+        requires(not can_get_nth<Tpl, 0>)
+    constexpr explicit tuple(tuple_convert_tag, Tpl&&, std::index_sequence<>) noexcept {}
+
+    template <std::size_t>
+    void get() = delete;
+
+    bool operator==(tuple const&) const  = default;
+    auto operator<=>(tuple const&) const = default;
+};
+
+// Specialization for a 1-element tuple
+template <typename Single>
+class tuple<Single> {
+    using Type = nonvoid_t<Single>;
+    NEO_NO_UNIQUE_ADDRESS object_t<Single> _value;
+
+public:
+    using index_sequence = std::index_sequence<0>;
+
+    tuple() = default;
+
+    template <explicit_convertible_to<Type> Arg>
+    constexpr explicit tuple(tuple_construct_tag,
+                             Arg&& arg)  //
+        noexcept(nothrow_constructible_from<Type, Arg>)
+        : _value(NEO_FWD(arg)) {}
+
+    template <typename Tpl>
+        requires(can_get_nth<Tpl, 0>)
+    constexpr explicit tuple(tuple_convert_tag, Tpl&& tpl, std::index_sequence<0>) noexcept(
+        nothrow_constructible_from<Type, get_nth_t<Tpl, 0>>)
+        : _value(get_nth<0>(NEO_FWD(tpl))) {}
+
+    template <std::size_t N>
+        requires(N == 0)
+    constexpr add_lvalue_reference_t<Type> get() & noexcept {
+        return static_cast<add_lvalue_reference_t<Type>>(_value);
+    }
+
+    template <std::size_t N>
+        requires(N == 0)
+    constexpr add_const_reference_t<Type> get() const& noexcept {
+        return static_cast<add_const_reference_t<Type>>(_value);
+    }
+
+    template <std::size_t N>
+        requires(N == 0)
+    constexpr add_rvalue_reference_t<Type> get() && noexcept {
+        return static_cast<add_rvalue_reference_t<Type>>(_value);
+    }
+
+    template <std::size_t N>
+        requires(N == 0)
+    constexpr add_rvalue_reference_t<const Type> get() const&& noexcept {
+        return static_cast<add_rvalue_reference_t<const Type>>(_value);
+    }
+
+    bool operator==(tuple const&) const  = default;
+    auto operator<=>(tuple const&) const = default;
+};
+
+// Specialization for a 2-element tuple
+template <typename T, typename U>
+class tuple<T, U> {
+    NEO_NO_UNIQUE_ADDRESS object_t<T> _first;
+    NEO_NO_UNIQUE_ADDRESS object_t<U> _second;
+
+    using Tnv = nonvoid_t<T>;
+    using Unv = nonvoid_t<U>;
+
+    template <std::size_t N>
+    using _type = conditional_t<N, Unv, Tnv>;
+
+public:
+    using index_sequence = std::index_sequence<0, 1>;
+
+    tuple() = default;
+
+    template <convertible_to<Tnv> Arg1, convertible_to<Unv> Arg2>
+    constexpr explicit tuple(tuple_construct_tag,
+                             Arg1&& arg1,
+                             Arg2&& arg2)  //
+        noexcept(nothrow_constructible_from<Tnv, Arg1> and nothrow_constructible_from<Unv, Arg2>)
+        : _first(NEO_FWD(arg1))
+        , _second(NEO_FWD(arg2)) {}
+
+    template <typename Tpl>
+        requires(can_get_nth<Tpl, 1>)
+    constexpr explicit tuple(tuple_convert_tag, Tpl&& tpl, std::index_sequence<0, 1>) noexcept(
+        nothrow_constructible_from<Tnv, get_nth_t<Tpl, 0>>
+        and nothrow_constructible_from<Unv, get_nth_t<Tpl, 1>>)
+        : _first(get_nth<0>(NEO_FWD(tpl)))
+        , _second(get_nth<1>(NEO_FWD(tpl))) {}
+
+    template <std::size_t N>
+    constexpr _type<N>& get() & noexcept {
+        if constexpr (N)
+            return static_cast<Unv&>(_second);
+        else
+            return static_cast<Tnv&>(_first);
+    }
+
+    template <std::size_t N>
+    constexpr _type<N> const& get() const& noexcept {
+        if constexpr (N)
+            return static_cast<Unv const&>(_second);
+        else
+            return static_cast<Tnv const&>(_first);
+    }
+
+    template <std::size_t N>
+    constexpr _type<N>&& get() && noexcept {
+        if constexpr (N)
+            return static_cast<Unv&&>(_second);
+        else
+            return static_cast<Tnv&&>(_first);
+    }
+
+    template <std::size_t N>
+    constexpr _type<N> const&& get() const&& noexcept {
+        if constexpr (N)
+            return static_cast<const Unv&&>(_second);
+        else
+            return static_cast<const Tnv&&>(_first);
+    }
+
+    bool operator==(tuple const&) const  = default;
+    auto operator<=>(tuple const&) const = default;
+};
+
+}  // namespace neo::core
+
+template <typename... Ts>
+struct std::tuple_size<neo::core::tuple<Ts...>> {
+    constexpr static inline std::size_t value = sizeof...(Ts);
+};
+
+template <std::size_t N, typename... Ts>
+struct std::tuple_element<N, neo::core::tuple<Ts...>>
+    : neo::meta::tag<neo::meta::at<neo::core::tuple<Ts...>, N>> {};
diff --git a/src/neo/tuple.hpp b/src/neo/tuple.hpp
index 6c73308..7aaec9b 100644
--- a/src/neo/tuple.hpp
+++ b/src/neo/tuple.hpp
@@ -2,14 +2,14 @@
 
 #include "./attrib.hpp"
 #include "./concepts.hpp"
-#include "./declval.hpp"
 #include "./fwd.hpp"
+#include "./get.hpp"
 #include "./meta.hpp"
-#include "./pick_type.hpp"
-#include "./tag.hpp"
+#include "./type_traits.hpp"
+
+#include <neo/core/tuple.hpp>
 
 #include <compare>
-#include <concepts>
 #include <utility>
 
 namespace neo {
@@ -22,55 +22,6 @@ class tuple;
 template <typename... Ts>
 tuple(Ts&&... ts) -> tuple<decay_t<Ts>...>;
 
-struct tuple_construct_tag {};
-struct tuple_convert_tag {};
-
-namespace _tup_detail {
-
-template <auto>
-void get() = delete;
-
-template <typename T, std::size_t N>
-concept has_member_get_n = requires(T&& v) { NEO_FWD(v).template get<N>(); };
-
-template <typename T, std::size_t N>
-concept has_adl_get_n = requires(T&& t) { get<N>(NEO_FWD(t)); };
-
-}  // namespace _tup_detail
-
-template <typename Tpl, std::size_t Index>
-concept can_get_nth = requires {
-                          requires meta::len_v<remove_cvref_t<Tpl>> > Index;
-                          requires _tup_detail::has_adl_get_n<Tpl, Index>
-                              or _tup_detail::has_member_get_n<Tpl, Index>;
-                      };
-
-/**
- * @brief Invocable object template that attempts to access the Nth element of the given argument
- *
- * @tparam N The index to access.
- *
- * The object must have a member function template get<N>(), or an ADL-visitle
- * get<N>(t);
- *
- * This works for std::tuple, std::variant, neo::tuple, nad neo::nano_tuple
- */
-template <std::size_t N>
-struct get_nth_fn {
-    template <can_get_nth<N> T>
-    constexpr decltype(auto) operator()(T&& t) const noexcept {
-        if constexpr (_tup_detail::has_member_get_n<T, N>) {
-            return NEO_FWD(t).template get<N>();
-        } else {
-            using _tup_detail::get;
-            return get<N>(NEO_FWD(t));
-        }
-    }
-};
-
-template <std::size_t N>
-constexpr inline auto get_nth = get_nth_fn<N>{};
-
 /**
  * @brief Obtain the return type of calling get_nth<N>() with the given tuple type
  *
@@ -79,153 +30,15 @@ constexpr inline auto get_nth = get_nth_fn<N>{};
  */
 template <typename Tuple, std::size_t N>
     requires can_get_nth<Tuple, N>
-using tuple_get_t = decltype(get_nth<N>(NEO_DECLVAL(Tuple)));
-
-namespace _tup_detail {
-
-/// An indexed box to hold tuple elements
-template <std::size_t, typename T>
-struct nth_box {
-    // The value for this element
-    NEO_NO_UNIQUE_ADDRESS T item;
-
-    constexpr nth_box() = default;
-    constexpr explicit nth_box(tuple_construct_tag, auto&& t)
-        : item(NEO_FWD(t)) {}
-
-    bool operator==(nth_box const&) const  = default;
-    auto operator<=>(nth_box const&) const = default;
-};
-
-template <typename Seq, typename Tpl>
-struct boxes;
-
-template <std::size_t... Is, neo_ttparam Tpl, typename... Ts>
-struct boxes<std::index_sequence<Is...>, Tpl<Ts...>> : nth_box<Is, Ts>... {
-    constexpr boxes() = default;
-
-    template <typename... Args>
-    constexpr explicit boxes(tuple_construct_tag tag, Args&&... args)  //
-        : nth_box<Is, Ts>(tag, NEO_FWD(args))... {}
-
-    bool operator==(boxes const&) const  = default;
-    auto operator<=>(boxes const&) const = default;
-};
-
-template <std::size_t... Ns>
-constexpr bool equal(const auto& left, const auto& right, std::index_sequence<Ns...>) noexcept {
-    return (static_cast<bool>(left.template get<Ns>() == right.template get<Ns>()) and ...);
-}
-
-constexpr auto compare_three_way(const auto&, const auto&, std::index_sequence<>) noexcept {
-    return std::strong_ordering::equal;
-}
-
-template <std::size_t I, std::size_t... Ns>
-constexpr std::strong_ordering
-compare_three_way(const auto& lhs, const auto& rhs, std::index_sequence<I, Ns...>) noexcept {
-    const auto result
-        = std::compare_strong_order_fallback(lhs.template get<I>(), rhs.template get<I>());
-    if (not std::is_eq(result)) {
-        return result;
-    }
-    auto next = _tup_detail::compare_three_way(lhs, rhs, std::index_sequence<Ns...>{});
-    return next;
-}
-
-template <std::size_t I, std::size_t J, std::size_t K, std::size_t... Ns>
-constexpr std::strong_ordering
-compare_three_way(const auto& lhs, const auto& rhs, std::index_sequence<I, J, K, Ns...>) noexcept {
-    const auto i = std::compare_strong_order_fallback(lhs.template get<I>(), rhs.template get<I>());
-    if (i != 0) {
-        return i;
-    }
-    const auto j = std::compare_strong_order_fallback(lhs.template get<J>(), rhs.template get<J>());
-    if (j != 0) {
-        return j;
-    }
-    const auto k = std::compare_strong_order_fallback(lhs.template get<K>(), rhs.template get<K>());
-    if (k != 0) {
-        return k;
-    }
-    auto next = _tup_detail::compare_three_way(lhs, rhs, std::index_sequence<Ns...>{});
-    return next;
-}
-
-}  // namespace _tup_detail
+using tuple_get_t = get_nth_t<Tuple, N>;
 
 template <typename... Ts>
-class nano_tuple {
-public:
-    using index_sequence = std::make_index_sequence<sizeof...(Ts)>;
-
-private:
-    using boxes = _tup_detail::boxes<index_sequence, nano_tuple>;
-
-    NEO_NO_UNIQUE_ADDRESS boxes _boxes;
-
-    template <std::size_t N>
-    using _nth_box = _tup_detail::nth_box<N, meta::at<nano_tuple, N>>;
-
-    template <std::size_t N>
-    using _nth_type = meta::at<nano_tuple, N>;
-
-public:
-    nano_tuple() = default;
-
-    template <typename... Args>
-    constexpr nano_tuple(tuple_construct_tag,
-                         Args&&... args)  //
-        noexcept((nothrow_constructible_from<Ts, Args> and ...))
-        : _boxes(tuple_construct_tag{}, static_cast<Ts>(NEO_FWD(args))...) {}
-
-    template <typename Tpl, auto... N>
-    constexpr nano_tuple(tuple_convert_tag,
-                         Tpl&& tpl,
-                         std::index_sequence<N...>)  //
-        noexcept((nothrow_constructible_from<Ts, tuple_get_t<Tpl, N>> and ...))
-        : _boxes(tuple_construct_tag{}, static_cast<Ts>(NEO_FWD(tpl).template get<N>())...) {}
-
-    template <std::size_t N>
-    constexpr _nth_type<N>& get() & noexcept {
-        auto& box = static_cast<_nth_box<N>&>(_boxes);
-        return static_cast<_nth_type<N>&>(box.item);
-    }
-
-    template <std::size_t N>
-    constexpr _nth_type<N> const& get() const& noexcept {
-        auto& box = static_cast<const _nth_box<N>&>(_boxes);
-        return static_cast<_nth_type<N> const&>(box.item);
-    }
-
-    template <std::size_t N>
-    constexpr _nth_type<N>&& get() && noexcept {
-        auto& box = static_cast<_nth_box<N>&>(_boxes);
-        return static_cast<_nth_type<N>&&>(box.item);
-    }
-
-    template <std::size_t N>
-    constexpr _nth_type<N> const&& get() const&& noexcept {
-        auto& box = static_cast<const _nth_box<N>&>(_boxes);
-        return static_cast<_nth_type<N> const&&>(box.item);
-    }
-
-    bool operator==(nano_tuple const&) const
-        requires(equality_comparable<Ts> and ...)
-    = default;
-    auto operator<=>(nano_tuple const&) const
-        requires(totally_ordered<Ts> and ...)
-    = default;
-};
-
-template <typename... Ts>
-class tuple : public nano_tuple<Ts...> {
-    using _base = nano_tuple<Ts...>;
+class tuple : public core::tuple<Ts...> {
+    using _base = core::tuple<Ts...>;
 
 public:
     using index_sequence = typename _base::index_sequence;
-    using _base::get;
-    using _base::nano_tuple;
+    using _base::tuple;
 
     // clang-format off
     tuple(tuple&) = default;
@@ -236,92 +49,81 @@ class tuple : public nano_tuple<Ts...> {
     tuple& operator=(tuple&&) = default;
 
     /// XXX: MSVC has trouble with concepts in the conditional-explicit. Use an intrinsic instead:
-    explicit(not (neo_is_convertible_to(const Ts&, Ts) and ...))
-    constexpr tuple(const Ts&... ts)
-        noexcept((nothrow_constructible_from<Ts, const Ts&> and ...))
+    /**
+     * @brief Per-element copying constructor.
+     *
+     * Since the types of the arguments here are non-deduced, this constructor will cause
+     * construction at call sites if the corresponding argument cannot be deduced (e.g. is a bare
+     * braced initializer).
+     */
+    explicit(not (neo_is_convertible_to(nonvoid_t<Ts> const&, nonvoid_t<Ts>) and ...))
+    constexpr tuple(nonvoid_t<Ts> const&... ts)
+        noexcept((nothrow_constructible_from<nonvoid_t<Ts>, nonvoid_t<Ts> const&> and ...))
         requires (sizeof...(Ts) != 0)
-             and (constructible_from<Ts, const Ts&> and ... )
+             and (constructible_from<nonvoid_t<Ts>, nonvoid_t<Ts> const&> and ... )
         : _base(tuple_construct_tag{}, ts...)
         {}
 
-    template <explicit_convertible_to<Ts>... Args>
+    /**
+     * @brief Per-element converting constructor. Each argument given here is
+     * passed through to the corresponding element of the tuple.
+     *
+     * Each argument must be explicit-convertible to the corresponding underlying element type. This
+     * constructor is `explicit` if any sub-element requires an explicit conversion from
+     * the corresponding argument
+     */
+    template <explicit_convertible_to<nonvoid_t<Ts>>... Args>
+        // Don't let this be visible when Ts is empty. That confuses some compilers
         requires (sizeof...(Ts) > 0)
-    explicit(not (neo_is_convertible_to(Args&&, Ts) and ...))
+    // We are an explicit constructor if any sub-element requires an explicit conversion
+    explicit(not (neo_is_convertible_to(Args&&, nonvoid_t<Ts>) and ...))
     constexpr tuple(Args&&... args)
-        noexcept((nothrow_constructible_from<Ts, Args> and ...))
-        : _base(tuple_construct_tag{}, static_cast<Ts>(NEO_FWD(args))...)
+        // We are no-throw if all element conversions are also no-throw
+        noexcept((noexcept(static_cast<nonvoid_t<Ts>>(NEO_FWD(args))) and ...))
+        // Delegate to the base constructor:
+        : _base(tuple_construct_tag{}, NEO_FWD(args)...)
         {}
 
-    template <typename... Us>
-        requires (sizeof...(Us) == sizeof...(Ts))
-             and (constructible_from<Ts, const Us&> and ...)
-    explicit(not (neo_is_convertible_to(const Us&, Ts) and ...))
-    constexpr tuple(const tuple<Us...>& other)
-        noexcept((nothrow_constructible_from<Ts, const Us&> and ...))
-        : _base(tuple_convert_tag{}, other, index_sequence{})
-        {}
-
-    template <typename... Us>
-        requires (sizeof...(Us) == sizeof...(Ts))
-             and (constructible_from<Ts, Us&> and ...)
-    explicit(not (neo_is_convertible_to(Us&, Ts) and ...))
-    constexpr tuple(tuple<Us...>& other)
-        noexcept((nothrow_constructible_from<Ts, Us&> and ...))
-        : _base(tuple_convert_tag{}, other, index_sequence{})
-        {}
-
-    template <typename... Us>
-        requires (sizeof...(Us) == sizeof...(Ts))
-             and (constructible_from<Ts, Us&&> and ...)
-    explicit(not (neo_is_convertible_to(Us&&, Ts) and ...))
-    constexpr tuple(tuple<Us...>&& other)
-        noexcept((nothrow_constructible_from<Ts, Us&&> and ...))
+    /**
+     * @brief Tuple conversion constructor. Allows constructing a tuple from another
+     * tuple type that may have different elements, provided that there exists valid
+     * conversions between those elements.
+     *
+     * This constructor requires that the argument be a tuple-like type with the same
+     * number of elements, and that each element from the other tuple is explicit-convertible-to
+     * the corresponding element in this tuple. This constructor is explicit if any of
+     * the sub-element conversions requires an explicit conversion.
+     *
+     * The tuple is perfect-forwarded through during construction.
+     */
+    template <unalike<tuple> OtherTpl>
+        requires core::_tuple_detail::tuple_constructible<tuple, OtherTpl>
+    explicit(not core::_tuple_detail::tuple_convertible<OtherTpl, tuple>)
+    constexpr tuple(OtherTpl&& other)
+        noexcept(core::_tuple_detail::tuple_construct_nothrow<tuple, OtherTpl>)
         : _base(tuple_convert_tag{}, NEO_FWD(other), index_sequence{})
         {}
 
-    template <typename... Us>
-        requires (sizeof...(Us) == sizeof...(Ts))
-             and (constructible_from<Ts, const Us&&> and ...)
-    explicit(not (neo_is_convertible_to(const Us&&, Ts) and ...))
-    constexpr tuple(const tuple<Us...>&& other)
-        noexcept((nothrow_constructible_from<Ts, const Us&&> and ...))
-        : _base(tuple_convert_tag{}, NEO_FWD(other), index_sequence{})
-        {}
     // clang-format on
 
-    bool operator==(tuple const&) const
-        requires(equality_comparable<Ts> and ...)
-    = default;
-    auto operator<=>(tuple const&) const
-        requires(totally_ordered<Ts> and ...)
-    = default;
+    bool operator==(tuple const&) const  = default;
+    auto operator<=>(tuple const&) const = default;
 
-    template <equality_comparable_with<Ts>... Us>
+    template <typename... Us>
+        requires(equality_comparable_with<object_t<Us>, object_t<Ts>> and ...)
     constexpr bool operator==(tuple<Us...> const& rhs) const noexcept {
-        return _tup_detail::equal(*this, rhs, index_sequence{});
+        return core::_tuple_detail::equal(*this, rhs, index_sequence{});
     }
 
-    template <totally_ordered_with<Ts>... Us>
+    template <typename... Us>
+        requires(totally_ordered_with<object_t<Ts>, object_t<Us>> and ...)
     constexpr typename std::common_comparison_category<
-        typename std::compare_three_way_result<Ts, Us>::type...>::type
+        typename std::compare_three_way_result<object_t<Ts>, object_t<Us>>::type...>::type
     operator<=>(const tuple<Us...>& other) const noexcept {
-        return _tup_detail::compare_three_way(*this, other, index_sequence{});
+        return core::_tuple_detail::compare_three_way(*this, other, index_sequence{});
     }
 };
 
-template <>
-class tuple<> : nano_tuple<> {
-    using _base = nano_tuple<>;
-
-public:
-    using index_sequence = typename _base::index_sequence;
-    using _base::get;
-    using _base::nano_tuple;
-
-    bool operator==(tuple const&) const  = default;
-    auto operator<=>(tuple const&) const = default;
-};
-
 template <typename Tuple>
 using index_sequence_t = typename remove_reference_t<Tuple>::index_sequence;
 
@@ -446,30 +248,16 @@ struct std::tuple_size<neo::tuple<Ts...>> {
 
 template <std::size_t N, typename... Ts>
 struct std::tuple_element<N, neo::tuple<Ts...>>
-    : neo::meta::tag<neo::meta::at<neo::tuple<Ts...>, N>> {};
+    : neo::meta::tag<neo::nonvoid_t<neo::meta::pack_at<N, Ts...>>> {};
 
-template <typename... Ts>
-struct std::tuple_size<neo::nano_tuple<Ts...>> {
-    constexpr static inline std::size_t value = sizeof...(Ts);
-};
-
-template <std::size_t N, typename... Ts>
-struct std::tuple_element<N, neo::nano_tuple<Ts...>>
-    : neo::meta::tag<neo::meta::at<neo::nano_tuple<Ts...>, N>> {};
-
-// clang-format off
 template <typename... Ts, typename... Us>
-requires (sizeof...(Ts) == sizeof...(Us))
-     and (neo::has_common_type<Ts, Us> and ...)
+    requires(sizeof...(Ts) == sizeof...(Us)) and (neo::has_common_type<Ts, Us> and ...)
 struct neo::basic_common_type<neo::tuple<Ts...>, neo::tuple<Us...>> {
     using type = neo::tuple<neo::common_type_t<Ts, Us>...>;
 };
 
 template <typename... Ts, typename... Us, neo_tt1param Tq, neo_tt1param Uq>
-requires (sizeof...(Ts) == sizeof...(Us))
-     and (neo::has_common_reference<Ts, Us> and ...)
+    requires(sizeof...(Ts) == sizeof...(Us)) and (neo::has_common_reference<Ts, Us> and ...)
 struct std::basic_common_reference<neo::tuple<Ts...>, neo::tuple<Us...>, Tq, Uq> {
     using type = neo::tuple<neo::common_reference_t<Tq<Ts>, Uq<Us>>...>;
 };
-
-// clang-format on
diff --git a/src/neo/tuple.test.cpp b/src/neo/tuple.test.cpp
index d52791d..9f07d73 100644
--- a/src/neo/tuple.test.cpp
+++ b/src/neo/tuple.test.cpp
@@ -1,4 +1,7 @@
 #include "./tuple.hpp"
+#include "neo/concepts.hpp"
+#include "neo/get.hpp"
+#include <neo/testing.hpp>
 
 #include <catch2/catch.hpp>
 
@@ -9,6 +12,85 @@
 using neo::tuple;
 using neo::tuple_get_t;
 
+neo::testing::cx_test_case EmptyTuple = [](auto check) consteval {
+    neo::tuple<> empty;
+    check(empty == empty);
+    check(empty <= empty);
+    auto dup                   = empty;            // Copy-construct
+    empty                      = dup;              // Copy-assign
+    auto dup2 [[maybe_unused]] = NEO_MOVE(empty);  // Move-construct
+    dup                        = NEO_MOVE(empty);  // Move-assign
+    static_assert(neo::constructible_from<tuple<>>);
+    static_assert(neo::constructible_from<tuple<>, tuple<>&>);
+    static_assert(neo::constructible_from<tuple<>, tuple<> const&>);
+    static_assert(neo::constructible_from<tuple<>, tuple<>&&>);
+    static_assert(neo::constructible_from<tuple<>, tuple<> const&&>);
+    static_assert(not neo::constructible_from<tuple<>, tuple<int> const&&>);
+    // static_assert(neo::constructible_from<tuple<>, std::allocator_arg_t, std::allocator<void>>);
+};
+
+neo::testing::cx_test_case BasicTuple = [](auto check) consteval {
+    tuple<int> a{21};
+    check(a.get<0>() == 21);
+    check(a == a);
+    check(a == tuple{21});
+    auto b = a;
+    check(b == a);
+    b.get<0>() = 412;
+    check(b != a);
+    check(a < b);
+};
+
+neo::testing::cx_test_case TupleOrdering = [](auto check) consteval {
+    tuple<int, int> a{21, 41};
+    tuple<int, int> b{2, 79};
+    check(b < a);  // 21 < 2
+    b.get<0>() = 22;
+    check(b > a);  // 22 > 21
+    b.get<0>() = 21;
+    check(b > a);  // 79 > 41
+};
+
+neo::testing::cx_test_case TupleOfVoid = [](auto check) consteval {
+    tuple<void>             v1;
+    tuple<void, void>       v2;
+    tuple<void, void, void> v3 [[maybe_unused]];
+    auto                    dup = v2;
+    (void)dup;
+    dup = v2;
+    check(v1 == v1);
+    check(v2 == v2);
+
+    tuple<neo::unit> u1;
+    check(v1 == u1);
+    u1 = v1;  // okay
+
+    (void)tuple<void>(0);  // okay
+    static_assert(std::regular<tuple<void>>);
+    static_assert(std::regular<tuple<void, void>>);
+};
+
+neo::testing::cx_test_case TupleOfReferences = [](auto check) consteval {
+    int         a = 0, b = 1, c = 2;
+    tuple<int&> t1{a};
+    tuple<int&> t2{b};
+    tuple<int&> t3{c};
+    check(t1 == t1);
+    check(t2.get<0>() == 1);
+    check(t1 != t2);
+    a = 1;
+    // Both no refer to equal values, but the references are not equal:
+    check(t1.get<0>() == 1);
+    check(t2.get<0>() == 1);
+    check(t1 != t2);
+
+    // Compare against a tuple that holds a value
+    tuple<int> regular{1};
+    // Both values are 1
+    check(t1.get<0>() == 1);
+    check(regular.get<0>() == 1);
+};
+
 static_assert(neo::explicit_convertible_to<tuple<int>, tuple<double>>);
 static_assert(neo::convertible_to<tuple<int>, tuple<double>>);
 
@@ -34,34 +116,54 @@ TEST_CASE("Empty tuple") {
     regular_assertions<>();
 }
 
+TEST_CASE("Tuple with reference") {
+    int         i       = 42;
+    tuple<int&> t       = {i};
+    int         i2      = 51;
+    tuple<int&> another = {i2};
+    auto        first   = neo::get_nth<0>(another);
+    CHECK(first == i2);
+    CHECK(another.get<0>() == 51);
+    t = another;
+    CHECK(i == 42);
+}
+
 struct not_equality_comparable {};
 
 TEST_CASE("Equality and compare") {
-    static_assert(not neo::equality_comparable<tuple<not_equality_comparable>>);
-    static_assert(neo::equality_comparable<tuple<int>>);
-    static_assert(neo::equality_comparable<tuple<int, int>>);
-    static_assert(neo::equality_comparable<tuple<std::string, int>>);
-    static_assert(
+    STATIC_REQUIRE(not neo::equality_comparable<tuple<not_equality_comparable>>);
+    STATIC_REQUIRE(neo::equality_comparable<tuple<int>>);
+    STATIC_REQUIRE(neo::equality_comparable<tuple<int, int>>);
+    STATIC_REQUIRE(neo::equality_comparable<tuple<std::string, int>>);
+    STATIC_REQUIRE(
         neo::equality_comparable_with<tuple<std::string_view, int>, tuple<const char*, int>>);
+    STATIC_REQUIRE(
+        neo::totally_ordered_with<tuple<std::string_view, int>, tuple<const char*, int>>);
 
-    static_assert(not neo::equality_comparable_with<tuple<std::string_view, int>,
-                                                    tuple<const char*, not_equality_comparable>>);
+    STATIC_REQUIRE(not neo::equality_comparable_with<tuple<std::string_view, int>,
+                                                     tuple<const char*, not_equality_comparable>>);
 
     neo::tuple t1{1, 2};
     neo::tuple t2{2, 1};
     CHECK(t1 != t2);
     CHECK(t1 < t2);
     CHECK(t2 > t1);
+
+    {
+        neo::tuple<std::string_view, int> t1{"hey", 2};
+        neo::tuple<const char*, long>     t2{"aaa", 5};
+        CHECK(t1 > t2);
+    }
 }
 
 TEST_CASE("Const-ness") {
-    static_assert(std::assignable_from<tuple_get_t<tuple<int>&, 0>, int>);
-    static_assert(not std::assignable_from<tuple_get_t<const tuple<int>&, 0>, int>);
+    STATIC_REQUIRE(std::assignable_from<tuple_get_t<tuple<int>&, 0>, int>);
+    STATIC_REQUIRE(not std::assignable_from<tuple_get_t<const tuple<int>&, 0>, int>);
     using moveonly = std::unique_ptr<int>;
-    static_assert(std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly>&&, 0>>);
-    static_assert(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly>&, 0>>);
-    static_assert(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly> const&, 0>>);
-    static_assert(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly> const&&, 0>>);
+    STATIC_REQUIRE(std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly>&&, 0>>);
+    STATIC_REQUIRE(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly>&, 0>>);
+    STATIC_REQUIRE(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly> const&, 0>>);
+    STATIC_REQUIRE(not std::assignable_from<moveonly&, tuple_get_t<tuple<moveonly> const&&, 0>>);
 }
 
 TEST_CASE("Simple usage") {
diff --git a/src/neo/utility.hpp b/src/neo/utility.hpp
index 9bbd16f..69ecef5 100644
--- a/src/neo/utility.hpp
+++ b/src/neo/utility.hpp
@@ -5,7 +5,6 @@
 #include "./type_traits.hpp"
 
 #include <compare>
-#include <type_traits>
 
 namespace neo {
 
@@ -56,7 +55,7 @@ constexpr inline struct logical_and_t {
  */
 template <typename... Items>
 class any_of {
-    nano_tuple<const Items&...> _items;
+    core::tuple<const Items&...> _items;
 
     template <auto Oper, std::size_t... I, typename Other>
     constexpr bool _op_1(std::index_sequence<I...>, logical_or_t, Other&& o) const noexcept {
@@ -96,7 +95,7 @@ explicit any_of(const Items&...) -> any_of<Items...>;
  */
 template <typename... Items>
 class none_of {
-    nano_tuple<const Items&...> _items;
+    core::tuple<const Items&...> _items;
 
     template <auto Oper, std::size_t... I, typename Other>
     constexpr bool _op_1(std::index_sequence<I...>, Other&& o) const noexcept {
@@ -135,9 +134,9 @@ explicit none_of(const Items&...) -> none_of<Items...>;
 template <typename Arg, typename Low, typename High>
 constexpr bool between(Arg&& arg, Low&& low, High&& high) noexcept
     requires requires {
-                 arg <= high;
-                 arg >= low;
-             }
+        arg <= high;
+        arg >= low;
+    }
 {
     return (arg <= high) && (arg >= low);
 }
@@ -152,9 +151,9 @@ constexpr bool between(Arg&& arg, Low&& low, High&& high) noexcept
 template <typename Arg, typename Low, typename High>
 constexpr bool properly_between(Arg&& arg, Low&& low, High&& high) noexcept
     requires requires {
-                 arg < high;
-                 arg > low;
-             }
+        arg < high;
+        arg > low;
+    }
 {
     return (arg < high) && (arg > low);
 }